ScreenshotNeo
Sign in Get a free key

BlogHow-to

Fix APITemplate.io Screenshots That Miss Content Below the Fold

First identify whether you need a template image, a URL-to-PDF, or a browser screenshot. Then check capture scope, deferred rendering, and the request you actually sent.

By the ScreenshotNeo team4 October 202611 min read

If a screenshot misses content below the fold, first check what operation produced it. A viewport screenshot only includes the visible browser area. A full-page browser capture aims to include the document’s scrollable page, but can still miss content that appears only after scrolling, interaction, or a later render. APITemplate.io documents template-based image generation and URL-to-PDF conversion; the cited documentation does not establish a general-purpose webpage screenshot endpoint or a full-page screenshot setting. Its REST API reference and PDF generation guide describe those workflows.

Use the decision path below before changing parameters: identify the output you need, verify the endpoint, and check that the missing content exists in the rendered page before capture.

1. Identify what APITemplate.io operation you are using

What you need What the documented workflow does What to check
Image of an APITemplate.io design Generates an image from a saved image template and supplied overrides. Confirm the template ID, element names, and override data. This is template rendering, not a screenshot of an arbitrary webpage. See image generation documentation.
PDF of a public webpage Renders a URL using a headless Chromium browser and returns a PDF. Confirm you are calling create-pdf-from-url and expecting a PDF. The docs do not establish that this endpoint returns a screenshot image. See URL-to-PDF documentation.
Browser screenshot of a webpage A browser screenshot workflow captures either the viewport or the full scrollable page, depending on the tool and configuration. Verify which screenshot tool and capture mode your request uses. The APITemplate.io documentation cited here does not establish a general webpage screenshot endpoint.

If you expected a webpage image but sent a template image request, the fix is to use the workflow that matches the desired artifact. If you expected an image from a URL-to-PDF request, confirm whether a PDF is the intended output. Do not add an undocumented APITemplate.io “full page” parameter based on a setting from another browser tool.

2. Check whether the missing content rendered

Even with a browser full-page capture, content may not exist in the page yet. Common causes include lazy-loaded images, scroll-triggered animations, content inserted after an interaction, and virtualized lists that render only the items near the viewport. A capture operation does not necessarily trigger every scroll event or application-specific loading behavior.

  1. Open the same page in a browser at the same URL and with the same access conditions.
  2. Scroll to the missing section. If it appears only after scrolling, clicking, expanding a panel, or waiting, that is a rendering trigger to reproduce before capture.
  3. Check whether the page uses a virtualized list. If it does, items outside the rendered window may not exist in the document at capture time.
  4. Wait for a page-specific signal that means the required section is ready, such as a known element becoming visible or an application state completing.
  5. Capture again and inspect the actual output. A successful HTTP response alone does not show that the expected page content rendered.

For a screenshot tool you control, typical browser-automation remedies are to scroll through the page to trigger lazy loading, expand the needed content, wait for the relevant selector or application state, and only then take a full-page capture. Treat these as general browser techniques; they are not APITemplate.io request parameters.

3. Confirm endpoint, version, region, and expected output

Write down the complete endpoint path and API version from the request that failed. APITemplate.io’s current documentation describes v2 endpoints, including /create-image for template images and /create-pdf-from-url for URL-to-PDF conversion. It also lists regional endpoints. Choose the endpoint appropriate to your account, region, and data-residency needs; the documentation does not say that changing region fixes missing below-the-fold content.

The documented regional API reference includes regional hosts and operational constraints. For example, it lists request limits and payload limits that vary by endpoint/region. If you are troubleshooting a timeout or payload error, compare your request with the current REST API documentation. Those limits are not evidence of a screenshot-specific behavior.

4. Reproduce the documented APITemplate.io workflows

These examples help distinguish the documented operations. They do not configure a general webpage screenshot. Put credentials in an environment variable or secret manager; never commit a real API key.

Generate an image from a saved image template

curl -X POST "https://rest.apitemplate.io/v2/create-image?template_id=YOUR_TEMPLATE_ID" \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "overrides": [
      {"name": "title", "text": "Example title"}
    ]
  }'

The request supplies a template ID and overrides for named elements. The response includes a download URL for the generated image. Verify that the template’s element name matches the override and that the returned output is the artifact you expected. Details: APITemplate.io image generation.

Generate a PDF from a publicly accessible URL

curl -X POST "https://rest.apitemplate.io/v2/create-pdf-from-url" \
  -H "X-API-KEY: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/page",
    "settings": {
      "paper_size": "A4",
      "orientation": "1",
      "margin_top": "10",
      "margin_right": "10",
      "margin_bottom": "10",
      "margin_left": "10"
    }
  }'

This produces a PDF from a URL, not a screenshot image. The documentation describes settings such as paper size, orientation, and margins; consult the current endpoint documentation for the complete supported settings and accepted values. Do not assume these PDF settings control browser screenshot dimensions or lazy loading.

Python: call the documented URL-to-PDF endpoint

import os
import requests

api_key = os.environ["APITEMPLATE_API_KEY"]
endpoint = "https://rest.apitemplate.io/v2/create-pdf-from-url"
payload = {
    "url": "https://example.com/page",
    "settings": {
        "paper_size": "A4",
        "orientation": "1",
        "margin_top": "10",
        "margin_right": "10",
        "margin_bottom": "10",
        "margin_left": "10",
    },
}

response = requests.post(
    endpoint,
    headers={"X-API-KEY": api_key, "Content-Type": "application/json"},
    json=payload,
    timeout=90,
)
response.raise_for_status()
print(response.json())

Install the dependency with python -m pip install requests. The endpoint response and download behavior are described in APITemplate.io’s PDF generation guide; handle its response according to the current API documentation.

Node.js: call the documented URL-to-PDF endpoint

const apiKey = process.env.APITEMPLATE_API_KEY;
if (!apiKey) throw new Error("Set APITEMPLATE_API_KEY");

const response = await fetch(
  "https://rest.apitemplate.io/v2/create-pdf-from-url",
  {
    method: "POST",
    headers: {
      "X-API-KEY": apiKey,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      url: "https://example.com/page",
      settings: {
        paper_size: "A4",
        orientation: "1",
        margin_top: "10",
        margin_right: "10",
        margin_bottom: "10",
        margin_left: "10",
      },
    }),
  },
);

if (!response.ok) {
  throw new Error(`APITemplate.io returned HTTP ${response.status}: ${await response.text()}`);
}
console.log(await response.json());

Run with a Node.js version that provides the built-in fetch. This is a PDF request. For a browser screenshot, use the screenshot tool’s own documented API and capture options.

5. Fix a browser screenshot workflow you control

If you are using Playwright or another browser automation library, the dependable sequence is: navigate, trigger the required content, wait for a meaningful readiness condition, then capture. The example below is illustrative Playwright code, not an APITemplate.io integration.

import { chromium } from "playwright";

const browser = await chromium.launch({ headless: true });
const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });

try {
  await page.goto("https://example.com/long-page", { waitUntil: "domcontentloaded" });

  // If the page lazy-loads on scroll, scroll in steps to trigger its loading logic.
  await page.evaluate(async () => {
    const step = Math.max(300, Math.floor(window.innerHeight * 0.8));
    for (let y = 0; y < document.documentElement.scrollHeight; y += step) {
      window.scrollTo(0, y);
      await new Promise((resolve) => setTimeout(resolve, 150));
    }
    window.scrollTo(0, 0);
  });

  // Prefer a selector that represents the content you need over an arbitrary long delay.
  await page.locator("#bottom-section").waitFor({ state: "visible", timeout: 15000 });
  await page.screenshot({ path: "page.png", fullPage: true });
} finally {
  await browser.close();
}

Install Playwright with npm install playwright and install its browser with npx playwright install chromium. Adapt the selector and trigger to the page. The scrolling loop is a practical starting point, not a universal solution: long pages can be expensive to traverse, content can load asynchronously after each step, and virtualized pages may replace earlier rows as you scroll. If the needed section requires a click or expansion, perform that interaction explicitly before capture.

6. Troubleshooting common symptoms

Symptom Likely cause Next step
Only the initially visible area appears in an image The operation captured a viewport, or the endpoint creates a template image rather than a webpage capture. Confirm the exact endpoint and output type. Use a documented full-page browser capture when you need a webpage image.
The output is a PDF when you expected PNG or JPEG You used the URL-to-PDF workflow. Confirm the intended artifact. The cited APITemplate.io URL workflow is PDF generation; use a screenshot product for a webpage image.
The bottom section is blank or incomplete Deferred content may not have loaded before capture, or the page needs scrolling or interaction. Reproduce the trigger in a browser, wait for a content-specific condition, and inspect the new output.
Some list entries never appear The page may virtualize its list and render only a moving window of items. Use an application-supported export or load all required data before capture. A single full-page operation may not preserve virtualized rows.
The capture works manually but fails in automation The automated request may differ in URL, authentication, viewport, timing, region, or network access. Compare those inputs and record the exact endpoint, API version, region, and sanitized request settings.
HTTP 401 or 403 Missing, invalid, or unauthorized API key; the target page may also restrict access. Send the key in the documented X-API-KEY header and check access. Keep the key secret; see API key guidance.
HTTP 429 The REST API rate limit was reached. Pause before retrying and reduce request concurrency. The REST API reference documents rate limits and recommends asynchronous generation for high-volume workloads.
Timeout or failed load The target may be slow, blocked, inaccessible to the renderer, or the request may exceed an endpoint constraint. Check that the URL is publicly accessible from the rendering service, inspect assets and network restrictions, and compare the selected region and endpoint limits with current docs.
Image or font is missing A dependent asset may be blocked, private, or unavailable to the rendering service. Check the asset URL and access policy. APITemplate.io documents outbound IPs for resources behind a firewall or CDN in its REST API reference.
Override has no effect on template image The override name may not match a named template element, or the wrong template ID was sent. Verify the saved template and element names in the image editor and compare them with the request.

7. Reliability, performance, and cost considerations

  • Use a meaningful readiness check. Waiting for a specific section or application state is more reliable than assuming a fixed delay is sufficient. If the page has no stable selector, define a page-specific signal or instrument the page.
  • Keep capture inputs reproducible. Record URL, endpoint/version, region, viewport (for browser screenshots), trigger steps, and relevant settings. This makes it possible to tell a content timing problem from a request mismatch.
  • Control retries. Retry transient network failures and rate limits with backoff, but do not retry a deterministic wrong-endpoint or missing-content issue unchanged. Avoid sending repeated synchronous requests at high concurrency.
  • Account for long pages. Scrolling to trigger lazy content takes additional browser work. Large pages, complex scripts, and many images can increase render time and memory use. Virtualization may require application-level handling rather than a longer wait.
  • Review API limits before scaling. APITemplate.io’s REST API reference lists rate and concurrency limits, regional timeout and payload constraints, and an asynchronous option for high-volume generation. Check the current docs for the exact endpoint you use.
  • Protect credentials and page data. Keep the API key out of source control and support tickets. Share a sanitized request and describe the missing content; include a public test URL only when it is safe to disclose.
  • Check your plan and usage. The supplied documentation establishes technical API behavior, not a price for your specific account or workload. Consult your APITemplate.io account and current pricing before estimating cost.

8. What to include in a support request

  • Exact endpoint and API version, with secrets removed.
  • Region or regional host.
  • Expected output (template image, URL-to-PDF, or browser screenshot).
  • Sanitized request body and relevant settings.
  • URL or template ID, if safe to share.
  • What content is missing, whether it appears after scrolling or interaction, and a description of the returned output.
  • HTTP status, response body with sensitive data removed, and approximate time of the request.

APITemplate.io instructs users to send the API key in the X-API-KEY header and keep it secret. Never include a live key in a ticket or example. Its API key guide explains key handling.

Or skip the browser setup

If your goal is a clean image of a webpage, ScreenshotNeo is a website screenshot API and MCP server. One GET request returns a PNG, JPEG, WebP, or PDF. Its capture can accept cookie and consent banners and remove 60+ known consent platforms, newsletter popups, and chat widgets before the shot. Bot checks, blank pages, timeouts, and failed loads are never billed; cache hits are also free, and response headers report the page verdict and billing status. An MCP server gives Claude, Cursor, and other MCP clients the take_screenshot, get_page_info, and capture_pdf tools. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000.

See the ScreenshotNeo API documentation for its options and configuration.

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}`);

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

FAQ

Does APITemplate.io have a full-page screenshot parameter?

The cited official documentation describes template image generation and URL-to-PDF conversion; it does not establish a general webpage screenshot endpoint or full-page screenshot parameter. Verify your exact endpoint and API version before relying on a parameter.

Will URL-to-PDF conversion give me a screenshot image?

The documented URL workflow creates a PDF. If the required artifact is PNG, JPEG, or WebP, use a webpage screenshot workflow that documents image output.

Why does full-page capture still miss lazy-loaded content?

Some pages load content in response to scrolling, interaction, or application state. Make the relevant content render before capture and verify it in the resulting file.

Should I send my API key to support?

No. Send a sanitized request and remove the key. APITemplate.io documents the key as a secret sent in the X-API-KEY header.

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.