ScreenshotNeo
Sign in Get a free key

BlogHow-to

Fix PagePeeker Screenshots with Missing Fonts or Icons

Diagnose missing fonts or icons in PagePeeker thumbnails by checking public asset access, cached results, and capture diagnostics.

By the ScreenshotNeo team4 October 20269 min read

If fonts or icons are missing from a PagePeeker thumbnail, first confirm that the page’s font files, stylesheets, and icon assets can be fetched from the public internet. Then check whether you are looking at a cached thumbnail or an unfinished render, and inspect PagePeeker’s capture headers if your account exposes them. PagePeeker’s public documentation does not describe a specific font-loading option or guarantee a fix for missing glyphs, so treat refresh and wait as diagnostic steps, not proven font fixes.

1. Check whether the page’s assets are publicly reachable

A screenshot service renders a page from its own environment. A font that works in your browser may still be unavailable to a remote renderer if it requires a logged-in session, comes from a local development server, is blocked by network rules, or points to a broken URL. This is a general troubleshooting check; PagePeeker’s public documentation reviewed here does not detail its asset-fetch policy.

  1. Open the affected page in a private browser window while signed out. Check whether the fonts and icons still appear.
  2. In browser developer tools, inspect the Network panel while reloading the page. Look for failed font files, stylesheets, SVGs, and icon resources. Note HTTP errors and blocked requests.
  3. Check the asset URLs themselves in a signed-out browser. They should resolve over the public internet, without a VPN, local hostname, private IP, or session cookie.
  4. Check the page’s CSS for the actual font and icon URLs. A CSS file can load successfully while its referenced font file fails.
  5. If assets come from another origin, verify that the URL is correct and that the origin is available to external requests. Do not assume a font failure is a CORS issue without evidence; inspect the browser’s specific error.

For icon fonts, check that the font file loads and that the expected font family and glyph mapping are applied. If the page uses an icon font subset, verify that the missing glyph is present in the deployed subset. For SVG icons, inspect whether the referenced SVG or sprite is publicly accessible and whether the page uses a URL that works outside the application session.

2. Determine whether the thumbnail is stale or still generating

PagePeeker says generated thumbnails are cached on its servers for several days. A site-side asset fix may therefore not appear in the image you are currently viewing. PagePeeker documents refresh=1 to request regeneration and the optional wait parameter to wait for a generated thumbnail rather than immediately receive a placeholder. Both are documented as premium options; check your account entitlement before relying on them. Neither option is documented as a font or icon repair setting.

The V2 API is PagePeeker’s recommended current API. Its documented direct-link shape is:

https://api.pagepeeker.com/v2/thumbs.php?size=m&code=YOUR_API_KEY&url=https%3A%2F%2Fexample.com

For a premium account that has access to the relevant options, a regeneration request can look like this:

https://api.pagepeeker.com/v2/thumbs.php?size=m&code=YOUR_API_KEY&refresh=1&wait=20&url=https%3A%2F%2Fexample.com

Use the actual site URL and an appropriately URL-encoded value. The wait value is a maximum number of seconds, not a promise that the renderer will finish within that time. If the image still contains missing glyphs after an eligible refresh, continue diagnosing the assets and capture result rather than repeatedly forcing renders.

3. Make a request and inspect the response

These examples request a PagePeeker V2 medium thumbnail and save the response. Use the API entry point and account key appropriate to your account. The key is optional for some account types, but PagePeeker recommends using it only server-side and warns against exposing it in client-side pages.

cURL

curl -sS -D pagepeeker-headers.txt -o thumbnail.jpg \
  --get 'https://api.pagepeeker.com/v2/thumbs.php' \
  --data-urlencode 'size=m' \
  --data-urlencode 'code=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com'

For an account entitled to premium regeneration and wait parameters, add these query values to the request:

  --data-urlencode 'refresh=1' \
  --data-urlencode 'wait=20'

Python

import requests

params = {
    "size": "m",
    "code": "YOUR_API_KEY",
    "url": "https://example.com",
}
# Add only if your PagePeeker account supports these premium options:
# params["refresh"] = "1"
# params["wait"] = "20"

response = requests.get(
    "https://api.pagepeeker.com/v2/thumbs.php",
    params=params,
    timeout=90,
)
response.raise_for_status()

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

for name, value in response.headers.items():
    if name.lower().startswith("x-pp-"):
        print(f"{name}: {value}")

Node.js

const params = new URLSearchParams({
  size: 'm',
  code: 'YOUR_API_KEY',
  url: 'https://example.com',
});
// Add only if your PagePeeker account supports these premium options:
// params.set('refresh', '1');
// params.set('wait', '20');

const response = await fetch(
  `https://api.pagepeeker.com/v2/thumbs.php?${params}`
);
if (!response.ok) {
  throw new Error(`PagePeeker request failed: ${response.status}`);
}

const bytes = new Uint8Array(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('thumbnail.jpg', bytes));
for (const [name, value] of response.headers) {
  if (name.toLowerCase().startsWith('x-pp-')) {
    console.log(`${name}: ${value}`);
  }
}

The API response is an image or, in some cases, a placeholder. Check the response headers and inspect the saved image; a successful HTTP response by itself does not establish that the screenshot contains the expected fonts.

4. Read PagePeeker’s capture diagnostics

For paid and unbranded accounts, PagePeeker documents these response headers:

Header What it helps you check
X-PP-Capture-Method The capture engine used. Record it for support; the public docs do not identify a renderer setting that fixes fonts.
X-PP-Capture-Time How long capture took. Useful context when a render seems incomplete, but not proof that waiting longer will fix a font.
X-PP-Final-URL The destination after redirects. Confirm the capture reached the expected page, locale, and public route.
X-PP-Hash A capture identifier PagePeeker says is useful for debugging a failed capture. Include it in a support request.
X-PP-Timestamp The Unix timestamp of the screenshot capture. Helps distinguish a new result from an older thumbnail.
X-PP-Error Whether PagePeeker reports an error creating the thumbnail. If true, investigate the failed capture as well as the asset issue.

Compare the requested URL with X-PP-Final-URL, and compare the timestamp before and after a refresh. A changed timestamp indicates a newer capture; it does not by itself show that the target’s fonts loaded.

5. If the thumbnail is not ready, use the documented readiness flow

PagePeeker documents a separate V2 readiness endpoint. Its example sequence is to request regeneration, poll the readiness endpoint, then retrieve the thumbnail. The readiness response is JSON with Error and IsReady fields. This can help distinguish a pending image from a completed result; it does not diagnose missing fonts.

# 1. Request regeneration (premium option; URL-encode the target)
curl -sS --get 'https://api.pagepeeker.com/v2/thumbs.php' \
  --data-urlencode 'size=m' \
  --data-urlencode 'code=YOUR_API_KEY' \
  --data-urlencode 'refresh=1' \
  --data-urlencode 'url=https://example.com'

# 2. Check whether the thumbnail is ready
curl -sS --get 'https://api.pagepeeker.com/v2/thumbs_ready.php' \
  --data-urlencode 'size=m' \
  --data-urlencode 'code=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com'

# 3. Retrieve the image after IsReady is 1
curl -sS -o thumbnail.jpg --get 'https://api.pagepeeker.com/v2/thumbs.php' \
  --data-urlencode 'size=m' \
  --data-urlencode 'code=YOUR_API_KEY' \
  --data-urlencode 'url=https://example.com'

Poll at a modest interval with a finite deadline in your application. Stop if the JSON reports an error, the deadline expires, or the image becomes ready. Avoid tight loops that create needless API calls. Confirm the exact endpoint behavior and account access in the current PagePeeker documentation.

6. Common causes and fixes

Symptom Likely check Action
Every glyph from a custom font is replaced Font URL is private, invalid, or failing to load Test the font URL while signed out; correct the deployed CSS URL or make the intended asset publicly fetchable.
Only some icon glyphs are missing Wrong icon font family, missing glyph in a subset, or CSS mapping mismatch Inspect the deployed font file and CSS mapping; verify the particular code point exists in the shipped subset.
Icons appear as empty boxes Icon font or SVG resource did not load, or the expected glyph is unavailable Check failed network requests and the exact asset URL; verify the icon’s asset and mapping on the public page.
Browser shows the fix, thumbnail does not The displayed thumbnail may be cached Check the capture timestamp; if entitled, request refresh and retrieve the new image.
Placeholder appears instead of a screenshot Render may still be pending Use the documented readiness flow or premium wait option if available; respect a finite timeout.
Final URL is unexpected Redirect, locale routing, or access gate changed the destination Inspect X-PP-Final-URL and test the resulting public URL directly.
X-PP-Error: True PagePeeker reports an error creating the thumbnail Record the headers and timestamp, then send the reproducible details to PagePeeker support.
No X-PP-* headers are visible Account type or response path may not expose the documented diagnostics Check the account/API configuration and provide the request time and target URL to support.

PagePeeker’s public documentation reviewed for this guide does not specify a font-loading toggle, supported font formats, browser version, or a font-specific renderer procedure. Do not assume that changing capture method, increasing wait time, or using full-page capture repairs missing glyphs.

7. Escalate with a reproducible capture

If the public page loads its assets correctly but the refreshed PagePeeker result still omits them, contact PagePeeker through its contact form. Include:

  • The exact public target URL and the approximate time of the request, including timezone.
  • The requested thumbnail size and whether you requested a refresh or wait.
  • The response values for X-PP-Capture-Method, X-PP-Capture-Time, X-PP-Final-URL, X-PP-Hash, X-PP-Timestamp, and X-PP-Error, when available.
  • Which fonts or icons are absent, and whether their asset URLs load in a signed-out browser.
  • A copy of the returned thumbnail, if appropriate.

Do not include your API key in a public issue or an untrusted support channel.

8. Performance, reliability, and cost considerations

PagePeeker says generated thumbnails are cached for several days, so reuse an existing thumbnail when freshness is not required. Its robot page describes an attempt to fetch a site once every 5–7 days; that is a service-level description, not a guarantee for a particular retry or account. Premium refresh and wait controls may cause additional work and are account-dependent. Use them for a specific diagnostic or freshness need, not as a repeated substitute for checking the assets.

PagePeeker’s API documentation says API calls can include displaying an existing thumbnail, creating one, checking readiness, and other API calls. Account quotas and entitlements matter when adding polling or refresh logic. Check the current V2 API documentation and FAQ for current behavior. Avoid making reliability claims from one successful render: record the capture time and result when comparing outcomes.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. It offers a one-request capture, and its documented features include accepting cookie and consent banners and removing known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be turned off. Its responses identify page verdict and billing status; bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing. AI agents can use its MCP server tools, including take_screenshot, get_page_info, and capture_pdf. The product facts here are specific to ScreenshotNeo and do not establish that it will fix a particular PagePeeker render or guarantee every external font will load.

Example using cURL:

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

For setup and available options, see the ScreenshotNeo documentation. 1,000 screenshots a month are free with no card; paid plans start at $5 for 3,000 screenshots. Create a free ScreenshotNeo account.

FAQ

Why are fonts missing in my PagePeeker screenshot?

The asset may not be accessible to the remote render, or the displayed image may be an older cached result. Check the font URL from a signed-out browser and compare the capture timestamp.

How do I fix icons missing from a PagePeeker thumbnail?

Check whether the icon font or SVG loads on the public page and whether the CSS maps the intended glyph. The PagePeeker docs reviewed do not publish a dedicated icon repair setting.

Does refresh=1 fix missing fonts?

It requests regeneration for eligible premium accounts. It can reveal whether a newer capture reflects a site-side fix, but PagePeeker does not document it as a font fix.

How long should I wait for a thumbnail?

The wait option accepts a maximum wait time and may return a placeholder if the render is not ready. It is premium and does not guarantee font loading.

What should I send PagePeeker support?

Send the target URL, approximate request time, requested size, refresh status, missing asset description, and available X-PP-* headers, especially the hash, timestamp, final URL, and error status.

Sources

Keep reading

7 min read

Full-Page Capture Chrome Plugin

Capture an entire webpage in Chrome with extensions, understand their limits, and automate clean full-page screenshots with ScreenshotNeo.

7 min read

Facebook Open Graph Debugger

Use Facebook’s Open Graph debugger to refresh stale link previews, verify metadata, and fix incorrect titles, descriptions, and images.