2026-11-11, Brand Monitoring · GEO · Tutorials

AI answer screenshots: evidence of what an engine showed

A parsed answer tells you what an engine said. When a client, a legal team or a regulator asks to see it, a JSON field is weak evidence. A screenshot and a copy of the page are stronger, especially when they are stored with the time of capture and a hash. This post shows how to request both, what each one contains, and how to keep them.

Two flags

Add include flags to any monitoring request:

• include.screenshot: a full-page PNG of the engine’s page once the answer finished, in result.screenshot.
• include.html: a copy of the page the answer was read from, in result.html. It opens with its scripts off, so it shows the page and runs nothing.

Both are free. The request costs the same with or without them: for example $0.0015 for a ChatGPT request at the Starter tier (pricing).

A refused flag costs nothing: the 400 comes back before anything runs. On ChatGPT, Gemini and Perplexity the HTML copy is the answer in the engine’s own page, with its headings, lists, tables and citation chips. Details per engine are in output formats.

What can be missing

• A screenshot or a copy can be absent when the answer was read without a rendered page or the page was not available. On Grok the public page is sometimes not available. The request is not an error and costs the same.
• Images on the page are not loaded. They show as empty boxes or broken-image icons.
• With a state, ChatGPT and Gemini answer from inside that US state and the other engines for the whole US; every engine returns the copies as usual. See US states.

Write your storage code so a missing field is a normal case.

What a response looks like

An example, with the answer fields left out. The links follow the format of the real ones:

{
  "success": true,
  "result": {
    "html": "https://files.answerline.dev/html/c45a5081-808d-4ed3-9c86-e4baf16c8ab8/1/page-1.html",
    "screenshot": "https://files.answerline.dev/html/c45a5081-808d-4ed3-9c86-e4baf16c8ab8/1/3f9a1c2e8b7d4a6f9e0c1b2a3d4e5f60/page-1.png",
    "provenance": {
      "capturedAt": "2026-11-11T09:14:03.512Z",
      "prompt": "Which project management tools suit a 10-person agency?",
      "requestedCountry": "US",
      "interface": "mobile-web",
      "loginState": "signed_out",
      "attempt": 1,
      "complete": true,
      "searchMode": "engine-default",
      "wireCaptured": true
    }
  }
}

On Google Search, html and screenshot are arrays with one link per results page, in page order. result.provenance comes with every answer and is free. capturedAt is the time to cite. The field list is in output formats.

The file links are public: anyone who has a link can open it. Share them as you would share a file.

Keep the files before they are deleted

Results, HTML copies and screenshots are deleted a few days after the task finishes (privacy policy). Evidence you may need next quarter has to live in your own storage. This script runs a ChatGPT request, downloads every file it links, and writes a manifest with a SHA-256 hash of each file:

import hashlib
import json
import os
import pathlib

import requests

HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}

r = requests.post(
    "https://api.answerline.dev/v1/monitor/chatgpt",
    headers=HEADERS,
    json={
        "prompt": "Which project management tools suit a 10-person agency?",
        "country": "US",
        "include": {"html": True, "screenshot": True},
    },
    timeout=630,
)
r.raise_for_status()
result = r.json()["result"]


def links(value):
    if value is None:
        return []
    return value if isinstance(value, list) else [value]


folder = pathlib.Path("evidence") / result["provenance"]["capturedAt"].replace(":", "-")
folder.mkdir(parents=True, exist_ok=True)
(folder / "answer.json").write_text(json.dumps(result, indent=2))

files = []
for i, url in enumerate(links(result.get("html")) + links(result.get("screenshot")), 1):
    body = requests.get(url, timeout=60).content
    name = f"{i}-{url.rsplit('/', 1)[-1]}"
    (folder / name).write_bytes(body)
    files.append({"url": url, "file": name, "sha256": hashlib.sha256(body).hexdigest()})

manifest = {"provenance": result["provenance"], "files": files}
(folder / "manifest.json").write_text(json.dumps(manifest, indent=2))

For a schedule, send async tasks with a webhook and run the download in the webhook handler, so files are saved minutes after the answer instead of days. The webhooks docs show how to verify the signature first.

Using the evidence

• Store the hash where the files cannot be edited, for example a write-once bucket or a ticket. A later hash that matches proves the file did not change.
• Keep answer.json next to the screenshot. The parsed citations and brand mentions are what you count. The screenshot is what you show.
• Answers change between runs of the same prompt. One screenshot shows one answer at one time, not what every user sees. Run the prompt several times before you report a pattern. AI answer volatility covers how much to expect.
• In the dashboard, each task page shows the answer, its sources, the screenshot and the saved HTML, which is enough for a quick check without code.

For reports built on these captures, see the AI visibility report template and competitor AI answer monitoring.

Next step

A new account gets 100 free requests. Run a prompt you report on with include.screenshot and include.html and open both files. Field reference: output formats.

Keep reading