Why Does Thumbalizr Show an Old Version of My Webpage?

Thumbalizr can show an older image because it reused a previous capture, or because a new capture loaded old HTML, CSS, JavaScript, or images from the target site or an intermediary cache. First check the response headers: X-Thumbalizr-Generated tells you when the screenshot was generated, X-Thumbalizr-Status tells you whether it is queued, complete, or failed, and X-Thumbalizr-Error may explain a failure. If the capture is old, request a new one with a different timestamp where your API and plan support it. If it is recent, investigate the page and its assets.

1. Identify which kind of “old” you are seeing

There are two separate things to diagnose: the screenshot service’s stored image and the content returned to its renderer.

Evidence	Likely explanation	Next step
`X-Thumbalizr-Generated` is older than expected	A prior capture may have been reused, or a new request was not made.	Check status and request a fresh capture with a changed timestamp if available.
Generated time is recent and status is `OK`, but the page looks old	The renderer may have received stale HTML or stale assets from the origin, CDN, proxy, or another cache.	Inspect the live target and the response headers/cache behavior of the affected resources.
Status is `QUEUED`	The capture is still processing.	Wait for completion and retrieve/check the result again.
Status is `FAILED` or an error header is present	The capture did not complete successfully.	Read `X-Thumbalizr-Error`; troubleshoot the reported failure before investigating freshness.

A recent screenshot generation time does not prove that every page resource was fresh. HTTP caches can serve a stored response while it is considered fresh, or revalidate it according to cache rules. A screenshot renderer captures the responses it receives. Compare the actual HTML, stylesheet, script, and image URLs used by the page rather than assuming the screenshot cache is responsible. See the [HTTP caching reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching).

2. Check Thumbalizr’s capture metadata

Inspect the headers from the screenshot response, not only the image itself. For a direct request, save the response headers and image separately:

curl -sS -D thumbalizr-headers.txt \
  "YOUR_THUMBALIZR_IMAGE_REQUEST_URL" \
  -o thumbalizr-shot.png

cat thumbalizr-headers.txt

Replace the placeholder with the exact request URL generated for your Thumbalizr API or Embed API integration. Treat signed URLs and credentials as secrets; do not paste them into a public issue.

X-Thumbalizr-Generated: compare this capture time with when you expected the update.
X-Thumbalizr-Status: QUEUED is not a completed result; OK indicates completion; FAILED means read the error details.
X-Thumbalizr-Error: use the returned explanation to address a failed capture.

The official [Thumbalizr Embed API documentation](https://thumbalizr.com/embed/) documents the current request options and response headers. The [legacy API documentation](https://thumbalizr.com/api/) remains available but identifies itself as legacy and recommends the Embed API.

3. Request a fresh capture

Thumbalizr documents timestamp as a way to generate a new thumbnail. Its explanation says the timestamp helps determine whether it should create a screenshot or render an existing one. When you need a refresh, send a timestamp value different from the one used for the prior request, following the request format for your API.

For an Embed API URL, the shape is conceptually:

https://thumbalizr.com/?url=ENCODED_TARGET_URL&timestamp=NEW_VALUE

This is a shape example, not a complete signed Embed API request. Use the official documentation’s required parameters and signing rules for your account. Do not copy a timestamp from an old documentation example as if it were current; generate a new value for the capture you want.

Refresh availability depends on API type and plan. The current Embed API table marks timestamp unavailable on the free tier and available on paid tiers; the legacy API also lists availability by tier. Thumbalizr’s features page lists on-demand “Picture Refresh” for certain plans. Plan features can change, so confirm the entitlement shown for your own account before relying on it. [Current Embed API](https://thumbalizr.com/embed/) · [Legacy API](https://thumbalizr.com/api/) · [Features](https://thumbalizr.com/features/)

Construct the request carefully

URL-encode the target URL and other query parameters. A target URL contains its own characters such as & and ?, which must not be mistaken for parameters of the screenshot request.
If you create a signed Embed API URL, compute the token from the same encoded query string you actually send. Changing encoding or parameter values after signing can invalidate it.
Change the timestamp value between refresh requests. Reusing the same value may not signal a new capture.
Keep the API key or Embed API secret private. Redact it from logs and support requests.

4. If the capture is new, inspect the target page and its assets

Open the target page in an ordinary browser and check whether the expected change appears there. Then inspect the specific resources that look old in the screenshot:

Identify the HTML page and the CSS, JavaScript, font, and image URLs that control the outdated content.
Request those URLs directly and inspect their response headers, including Cache-Control, Age, ETag, and Last-Modified when present.
Check the origin and CDN configuration for the relevant paths. Purge or revalidate the affected resource using your hosting/CDN’s documented process if it is serving an obsolete copy.
If the site uses versioned asset filenames, confirm the HTML references the new filename. A fresh HTML document can still point to an older asset.
Compare the response received from the public URL with the content deployed at the origin. A browser’s local refresh behavior alone does not establish what a remote renderer or intermediary received.

Do not add a random query parameter to every asset as a substitute for understanding the cache policy. Use the site’s normal versioning and cache invalidation strategy, and verify the returned resource.

5. Check rendering settings that can make a current page look outdated

A recent, successful capture can differ from the view you expect because the screenshot request uses different settings or captures before the page finishes updating.

Setting	What to check
`delay`	Thumbalizr documents a delay range of 1–30 seconds; five seconds is shown as a default for some tiers. A client-rendered page or delayed data may need longer. Choose a page-appropriate delay.
`bwidth`, `bheight`	Match the viewport to the browser size you are comparing against. Responsive layouts can show different content or breakpoints.
`size`	Check whether the request captures the visible screen or the full page. A section below the fold may be absent from a screen-only capture.
`country`	Compare the capture location with the browser session. Geolocation or regional content may differ.

These controls are documented in the [Thumbalizr Embed API](https://thumbalizr.com/embed/) and [legacy API](https://thumbalizr.com/api/). Compare like-for-like settings before deciding that a screenshot is stale.

6. Troubleshooting common problems

Symptom	Cause to check	Fix
The generated time is old	The request reused a previous capture or did not request a refresh.	Use a new `timestamp` if supported for your API and plan; verify the next response’s generation header.
The timestamp change has no effect	The account tier may not include timestamp refresh, the parameter may be malformed, or a signed request may no longer match its token.	Check current plan/API eligibility, URL-encode consistently, and sign the exact query sent.
Status remains `QUEUED`	The capture is not complete yet.	Follow the documented retrieval/status flow and wait for completion before evaluating the image.
Status is `FAILED`	The capture failed for a reported reason.	Read `X-Thumbalizr-Error` and resolve that condition first.
Generation time is current but one image, font, or style is old	A page resource may be cached independently of the HTML.	Check that resource’s URL and cache headers, then correct or invalidate the origin/CDN copy.
Screenshot shows an earlier state of a dynamic page	The page updates after the configured capture delay.	Increase `delay` within the documented range or use a page state that is ready before capture.
Screenshot differs only at some widths or locations	Viewport or country settings differ.	Set matching `bwidth`, `bheight`, `size`, and `country` values.
Request fails after changing URL parameters	Incorrect encoding or a signature computed over different parameters.	Encode the nested target URL correctly and regenerate the signature from the exact outgoing query.

7. Escalate with a useful diagnostic bundle

If a fresh successful capture still cannot be explained, send Thumbalizr support enough information to reproduce the issue:

Target page URL and the approximate time the change was published.
API type and plan, with secrets removed.
Exact request parameters, including the timestamp and capture settings.
Response headers, especially generated time, status, and error.
The returned image and a description of the expected difference.
Relevant target-page or asset response headers, if you found a likely cache issue.

Never include a private API key, signing secret, or an unredacted signed URL in a public ticket.

8. Or skip the browser setup

If you need a fresh screenshot without managing a browser-rendering service, [ScreenshotNeo](https://screenshotneo.com) is a website screenshot API and MCP server. Its one-request API returns a PNG, JPEG, WebP, or PDF. See the [ScreenshotNeo API documentation](https://screenshotneo.com/docs/) for request options.

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

import requests

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

const q = new URLSearchParams({
  access_key: 'YOUR_API_KEY',
  url: 'https://stripe.com'
});
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
const bytes = new Uint8Array(await res.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('shot.webp', bytes));

ScreenshotNeo removes cookie banners, newsletter popups, and chat widgets before capture; bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card, and paid plans start at $5 for 3,000. Sign up free for 1,000 screenshots a month, with no card required.

9. Performance, reliability, and cost considerations

Repeatedly forcing captures can add avoidable work and cost on services whose plans count every generated screenshot. First use the generation and status headers to establish whether a new capture is needed; then refresh only when the target has changed. Thumbalizr plan entitlements and refresh rules can change, so check the current account terms. The supplied Thumbalizr material does not establish a screenshot refresh price or a benchmark, so no cost or speed comparison can be inferred here.

For reliability, retain the request settings and capture metadata alongside the resulting image. This makes it easier to distinguish an old stored screenshot, an incomplete job, stale target resources, and a timing or viewport mismatch. When investigating, change one factor at a time and compare the response headers and image after each request.

Frequently asked questions

Will clearing my own browser cache refresh a Thumbalizr image?

Not necessarily. Your local browser cache and Thumbalizr’s stored capture or the target site’s caches are separate. Use the response metadata and a supported refresh request to determine which layer is involved.

Does a new timestamp guarantee that every part of the page is current?

No. It asks Thumbalizr for a new capture when supported. The renderer can still receive cached HTML or assets from the target site or an intermediary.

Why does the image look different from my logged-in browser?

The capture may not share your browser’s login state, viewport, country, or page timing. Compare the request settings and the publicly served page state.

Where should I start if I only have the image file?

Retrieve the response metadata for the request that produced it. Without the generation time and status, it is difficult to tell a reused image from a fresh capture of stale content.