How do I prove what an AI model said at a specific time?

What should I check, step by step?

1. Save the full JSON response from the API, not a copy of the text. OpenAI's Chat Completions object includes id, created (a Unix timestamp in seconds), model (the exact snapshot that answered) and system_fingerprint. Save the request you sent with it: messages, model, temperature, seed and any tools.

2. Store it yourself. Chat Completions only keeps a retrievable copy if you set store to true, and OpenAI's data controls page lists 30 days of application state for the Responses API and up to 30 days for abuse monitoring logs. Under Zero Data Retention, store is treated as false.
3. Compute a SHA-256 of the exact response bytes you saved, and of the request. Any later edit changes the hash.
4. Get the hash timestamped by someone other than you: an RFC 3161 timestamp authority, OpenTimestamps (which anchors to Bitcoin), or a receipt service. A timestamp you write yourself isn't evidence of anything.
5. For a ChatGPT conversation (no API response), make a shared link and also export or save the page. OpenAI's help page says a shared link is a snapshot up to when you shared it, can be updated, and stops working if the link or the chat is deleted.
6. Write down what you can't prove: that the text wasn't edited before you hashed it, and that the named model, rather than something else, produced it.

Why you can't just re-run the prompt

OpenAI's API reference describes seed as best effort and says determinism is not guaranteed. It tells you to compare system_fingerprint, which changes when the backend configuration changes, to see whether that might explain a different answer.

• Models change and get retired. OpenAI's deprecations page lists shutdown dates for older models, and Anthropic's models overview says that for models before the 4.6 generation the short alias is a pointer that resolves to a dated ID (from 4.6 on, every ID is a pinned snapshot). The exact model value in the saved response is the best record of which model answered.
• So the answer has to be captured and fixed when it's returned. Trying to reproduce it months later usually gives a different answer.

What each kind of evidence shows

Screenshot: easy to edit and has no trustworthy time. It's the weakest form.

• Saved API response: has the provider's id, created time and model snapshot. But the file is yours, so on its own it shows what you say the provider returned.
• Hash plus independent timestamp: RFC 3161 describes a timestamp authority as proof that a datum existed before a particular time. OpenTimestamps proofs, once confirmed (a few hours), say a Bitcoin block attests the hash existed by then, and anyone can verify that with a Bitcoin node. This shows the text was fixed by that time. It still doesn't show who wrote it.
• Provider-side copy: a stored completion can be fetched by its id with your API key for as long as it's kept. That's strong evidence for you, but a third party can't check it without access to your account.
• The response objects in OpenAI's and Anthropic's API references don't carry a signature over the output that an outsider can check. Anthropic's thinking-block signature is an encrypted copy of the reasoning that you pass back unchanged, and Anthropic's API uses it to verify the block came from Claude. An outsider can't check it.

When the AI got something wrong

For a hallucination or bad-advice dispute, keep the prompt as well as the output. What the model was asked, and with which system prompt and tools, usually decides who's responsible.

• Record what you did with the answer and when, alongside the hashed response. A timeline that starts with a timestamped response is much harder to argue with than a memory of it.