PagePeeker Screenshot Dimensions and Image Formats Explained

PagePeeker documents five standard thumbnail dimensions: 90×68, 120×90, 200×150, 400×300, and 480×360 pixels. Its reviewed API reference does not document a parameter for choosing PNG, JPEG, WebP, or another output format. Choose a documented size for the display slot, and inspect the actual HTTP response if the image format matters to your application.

This guide explains PagePeeker’s published size presets, what its documentation does and does not say about image formats, how to request and retrieve a thumbnail, and what to check before choosing a plan.

1. PagePeeker’s documented thumbnail dimensions

Preset	API value	Dimensions	Good fit
Tiny	t	90×68 px	Small lists where the thumbnail is only a visual cue.
Small	s	120×90 px	Compact cards and directory rows.
Medium	m	200×150 px	General-purpose thumbnail cards.
Large	l	400×300 px	Larger previews where page details need more room.
Extra large	x	480×360 px	The largest standard preset documented in the API reference.

These are thumbnail dimensions, not a promise that the source page will be captured as a full-length screenshot. PagePeeker’s pricing table lists full-length screenshots as a Premium feature. Premium accounts may have additional sizes, but the API page does not publish a complete list; confirm a required custom dimension with PagePeeker before building around it. PagePeeker API documentation · PagePeeker pricing.

Choosing the size

1. Measure the image slot in CSS pixels at the largest layout where it appears.
2. Choose a preset at least as large as that slot if you want to avoid enlarging a small image. For example, a 180-pixel-wide card can use Medium (200×150).
3. If the layout displays the thumbnail at a substantially smaller size, a smaller preset can reduce transfer and storage needs, depending on the returned image and your own caching pipeline.
4. Check the rendered composition. A fixed thumbnail aspect ratio can crop or scale the source page in a way that changes how its content reads.

The listed sizes share an approximately 4:3 aspect ratio. If your card uses a different ratio, decide whether your frontend will letterbox, crop, or distort the returned image. Avoid stretching the image; use proportional sizing and an explicit crop policy.

2. Does PagePeeker let you choose PNG, JPEG, or WebP?

The reviewed PagePeeker API reference documents size and request options, but it does not specify a caller-selectable image format or identify a definitive returned format. Do not assume a format query parameter or promise a particular format based on this documentation. This is a documentation limit, not proof that the live service can never return a particular format.

If your application requires a specific encoding, verify the behavior against the current service before depending on it:

1. Make a request for a known URL and size.
2. Record the HTTP status and response headers, especially Content-Type.
3. Inspect the downloaded bytes with an image decoder rather than trusting a filename extension.
4. Repeat for the request paths your application uses, including a cached result and a refreshed result if applicable.
5. If the format is a hard requirement, ask PagePeeker to confirm supported formats and whether the behavior is guaranteed.

Do not infer the file format from the endpoint path alone. A response header and successful decoder validation are stronger evidence than a locally chosen name such as thumbnail.jpg.

3. Request and retrieve a PagePeeker thumbnail

PagePeeker identifies API v2 as the current recommended API and says its original v1 API was discontinued and redirected to v2. The documented direct image endpoint has this shape:

http://{entrypoint}.pagepeeker.com/v2/thumbs.php?size={size}&code={code}&refresh={refresh}&wait={wait}&url={url}

Replace the placeholders with the entrypoint and values applicable to your account. URL-encode the target page’s URL; use an HTTP client’s query parameter support instead of concatenating an unescaped URL. The API documentation describes the account key as optional and recommends keeping it server-side because third-party use can count against your account’s call quota. Follow the current API documentation for the correct entrypoint and account parameters.

cURL example

This template demonstrates safe URL encoding by letting cURL encode query parameters. Fill in the documented entrypoint and any required account code for your use.

curl --get "http://{entrypoint}.pagepeeker.com/v2/thumbs.php" \
  --data-urlencode "size=m" \
  --data-urlencode "url=https://example.com/" \
  --output thumbnail-response

The output filename deliberately has no extension because the reviewed API reference does not establish a fixed image format. Check the response status, headers, and bytes before assigning a format-specific extension. Add the account code and optional parameters only as documented for your account.

Python example

import requests

endpoint = "http://{entrypoint}.pagepeeker.com/v2/thumbs.php"
params = {
    "size": "m",
    "url": "https://example.com/",
    # Add the documented account parameter if your integration needs it.
}

response = requests.get(endpoint, params=params, timeout=90)
response.raise_for_status()

content_type = response.headers.get("Content-Type", "not supplied")
print("Content-Type:", content_type)

with open("thumbnail-response", "wb") as image_file:
    image_file.write(response.content)

Install the dependency with python -m pip install requests. Treat the response as an image only after validating its status and content; an error or placeholder response should not be saved and served as if it were the final thumbnail.

Node.js example

const endpoint = new URL("http://{entrypoint}.pagepeeker.com/v2/thumbs.php");
endpoint.searchParams.set("size", "m");
endpoint.searchParams.set("url", "https://example.com/");
// Add documented account parameters when required.

const response = await fetch(endpoint);
if (!response.ok) {
  throw new Error(`PagePeeker returned HTTP ${response.status}`);
}

const contentType = response.headers.get("content-type") ?? "not supplied";
console.log("Content-Type:", contentType);

const bytes = Buffer.from(await response.arrayBuffer());
await import("node:fs/promises").then(({ writeFile }) =>
  writeFile("thumbnail-response", bytes)
);

Run this in a Node.js version with built-in fetch. Add a timeout using an abort signal in production, and validate that the response is the expected image or documented placeholder before publishing it.

4. Refreshing, waiting, and readiness polling

The API documentation describes two optional Premium-only parameters: refresh=1 to regenerate a thumbnail and wait to wait for a thumbnail instead of returning a placeholder. It also documents a readiness workflow using thumbs_ready.php: request or refresh the thumbnail, poll readiness, then retrieve the image. Consult the provider’s current API page for exact readiness request parameters and response meanings.

These options affect the request workflow, not the documented size presets or a documented output-format choice. For asynchronous work, use bounded polling with a delay and an overall deadline. Stop when the image is ready, the provider returns a terminal failure, or your deadline expires. Avoid tight polling loops that add load without making the rendering finish sooner.

5. Plan limits and operational tradeoffs

PagePeeker’s published plan pages were checked on 2026-10-03, and the pages reviewed do not show publication dates. Treat prices, quotas, rendering-time statements, and feature availability as time-sensitive provider claims, not independent measurements.

Plan	Published price	Monthly calls	Size	Cache	Stated typical rendering time
Free Branded	Free	No monthly limit listed	Up to 480×360	20 days	30–60 sec
Free Unbranded	Free	100,000	Up to 480×360	20 days	10–20 sec
Basic	$5.99/month	100,000	Up to 480×360	7 days	10–20 sec
Advanced	$39.99/month	1,000,000	Up to 480×360	5 days	5–15 sec
Premium	Custom	No limit listed	No limit listed	Customizable	Under 5 sec

The free-plan and pricing pages also describe branding or link-back conditions for free use. The pricing table marks mobile/tablet screenshots, full-length screenshots, and HTML-to-PDF unavailable on Basic and Advanced and available on Premium. Verify the current terms and your intended use on the free-plan page and pricing page before committing.

Performance, caching, and reliability

• Plan for asynchronous rendering. PagePeeker publishes typical rendering ranges, and its API offers readiness polling. Do not make a user-facing page depend on a fresh capture finishing synchronously; queue work or show a previously stored thumbnail while a refresh is pending.
• Cache at the application layer when appropriate. Reuse a result until your product needs a refresh. Respect the provider’s current cache and refresh behavior, and avoid refreshing the same URL repeatedly.
• Set timeouts and bounded retries. Retry transient network failures with backoff. Do not retry permanent input errors indefinitely.
• Validate before storing. Check status, content type when present, and whether the bytes decode as an image. Keep placeholder, failure, and completed-image states distinct in your database.
• Protect account credentials. Keep the account key server-side, as PagePeeker recommends, so visitors cannot reuse it and consume the account’s call quota.
• Budget against calls and latency, not image dimensions alone. The appropriate plan depends on the number of URLs, refresh cadence, required size, attribution conditions, and whether premium capture features are needed.

6. Troubleshooting

Symptom	Likely cause	What to do
The request returns an error or not an image	Malformed endpoint, missing or invalid parameter, or provider-side failure.	Check the current v2 documentation, encode the URL as a query parameter, inspect status and body, and avoid treating every response as an image.
The thumbnail appears to be a placeholder	The page may still be rendering, or the request did not wait for completion.	Use the documented readiness workflow; Premium accounts may use the documented wait option.
A changed page still shows an old thumbnail	The existing result may be cached.	Check the plan’s stated cache behavior. Premium accounts may use refresh=1 to regenerate, according to the API documentation.
The image looks blurry in the interface	The chosen preset is smaller than its displayed size or was enlarged by CSS.	Choose a larger documented preset, or display it closer to its intrinsic dimensions.
The image is cropped or has empty space	The card aspect ratio differs from the returned thumbnail’s proportions.	Set an explicit proportional fit or crop policy in the UI; do not stretch the image.
Your code cannot identify the image format	The reviewed reference does not specify a selectable or definitive output format.	Inspect Content-Type and decode the bytes. Ask PagePeeker for confirmation if format support is a requirement.
Calls are unexpectedly attributed to your account	A client-side integration may expose an account key to visitors.	Move the request behind your server and keep credentials out of browser code.
Captures are slower than expected	Rendering time varies by plan and request workflow; the published ranges are typical claims.	Queue captures, use readiness polling with a deadline, and show a cached prior result where suitable.

7. An alternative when you need control over screenshot output

For a workflow that needs explicitly selected PNG, JPEG, or WebP output, use a service whose documented API exposes that control and verify its response. PagePeeker’s reviewed reference does not document such a selector. ScreenshotNeo is the alternative to try first when you want documented output formats, clean captures, and billing that excludes failed or non-page results. See ScreenshotNeo and its API documentation.

8. Or skip the browser setup

ScreenshotNeo returns a screenshot or PDF from one GET request. Its API supports PNG, JPEG, and WebP; adapt the target URL below to the page you need to capture. See the ScreenshotNeo API documentation for parameters and configuration.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://example.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

• Cookie and consent banners, newsletter popups, and chat widgets are removed before capture; each cleanup step can be turned off.
• Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers report the page verdict and billing status.
• An MCP server gives AI agents tools to take screenshots, inspect page information, and capture PDFs.
• 1,000 screenshots per month are free with no card; paid plans start at $5 for 3,000. Every feature is available on every plan.

Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card.

9. FAQ

Can I request a custom PagePeeker size?

The API page says Premium accounts may have additional sizes, but it does not list every available dimension. Confirm a specific size with PagePeeker.

Are the documented sizes retina or device-pixel dimensions?

The API reference lists pixel dimensions for thumbnail presets but does not characterize them as retina-scaled output. If a precise pixel-density behavior matters, verify it with the provider.

Can I use the free plan commercially?

Check PagePeeker’s current free-plan terms for branding, link-back, and permitted-use requirements; the published free options differ on branding and monthly-call details.

Does a larger preset guarantee a sharper screenshot?

It provides more output pixels, but perceived sharpness also depends on the rendered page and how the image is resized in your interface.

Where can I confirm current plan details?

Use PagePeeker’s live free-plan and pricing pages, since the figures summarized here can change.