How to Capture and Archive Verbatim AI Answers About Your Company

Most teams start the same way. Someone sees what ChatGPT or Perplexity says about the company, takes a screenshot or copies a conversation link, and drops it in a shared folder. Three weeks later nobody can say which prompt produced it, which engine it came from, or whether the link still opens. This guide is for marketing leads who need to keep verbatim AI responses about my company in a form the team can actually find and trust later, which means a usable AI response log with the files behind every entry.

By the end you'll have a way to archive AI answers with the exact prompt, a UTC timestamp, the engine details, a searchable index, and a copy of each original that can be checked and restored. It doesn't cover whether an answer is right or what to do about a wrong one, only capture and storage. Even teams that already use AI brand monitoring tools usually want their own copy of what was shown.

The short version is to save the full prompt and answer without rewriting them, record when and where you captured them, keep a screenshot or PDF next to the searchable text, give each capture an ID, and keep protected copies with checksums.

You'll need access to the AI interfaces you want to document, a short list of prompts, an approved place to store files, a spreadsheet or database for the index, and a way to take screenshots or save PDFs. You don't need a new paid archive product. Check that you're allowed to store any customer details that show up in a conversation.

1. Define the prompts and records you will keep

Decide what counts as one record before you collect anything.

Give every question a stable prompt ID, such as P001, and store the exact wording in its own file, separate from the short label you use in reports. Give the wording a version number too. If you change the company name, the region or the phrasing, that's a new version, so P001 version 2 is a different test from version 1.

Then write down which engines and surfaces you'll capture. A surface is where you collected the answer, like the web app, a mobile app, a provider API or a monitoring platform, and an API answer doesn't show what a person saw in the web interface. Decide whether your standard collection starts a new conversation or continues a thread, and label it either way. Name a capture owner and an archive administrator too, who are responsible for the process and not for whatever the AI says.

Keep the prompt set small and plain: one question that describes the company, one about a product, and one about your buying category, marking which ones name your company. If you want the same prompts run on several engines, track the same prompts across ChatGPT, Gemini and Perplexity so each engine gets an identical test.

This is also a place where DeepSmith does some of the work. In AI Visibility you set the tracked prompts, they run on a schedule you choose, and each full answer is captured, so you can open the actual answer and not just a visibility percentage. Keep your own prompt IDs next to those tracked prompts, since versioning is a habit in your archive and not a setting in the product.

You're done with this step when every planned collection has an exact prompt, an ID, a version, an engine, a surface and an owner, and two teammates could tell whether they're running the same test.

Common mistake. Recording "brand reputation prompt" instead of the actual wording, or quietly rewording the question between runs. If the wording changes, the version changes.

2. Record the time and session conditions

Write down what you can observe, and mark the rest as unknown. You want someone who wasn't there to understand how the answer was produced.

For every capture, record the capture ID, the exact prompt and version, the engine and surface, the model label if the interface shows one, any visible mode like search or research, and the capture time in UTC. Add a separate field for a provider timestamp if the service gives you one, any conversation or response ID the interface shows, whether it was a new conversation or a follow-up, and the earlier messages or attachments. Also note whether you were signed in (using an alias, not a real login), the language and any region you set on purpose, anything you know about memory or custom instructions, and who collected it and how.

Use values like not displayed, not available and not checked on purpose, because they mean different things, and don't guess a model version from a logo.

For timestamps, use the RFC 3339 format with an explicit UTC marker, for example 2026-11-12T14:32:10Z, where the Z means UTC offset zero. In file names use a filename-safe version like 20261112T143210Z, and keep the full timestamp in the metadata. If you import an older record, keep the original provider timestamp and add the import time as a second field, because importing a file today doesn't mean the answer was generated today.

You're done when someone who didn't do the capture can tell which interface was used, can see the capture time apart from any provider time, and can see which conditions were known.

Common mistake. Saving only a date, using local time with no zone, or documenting the prompt while leaving out the earlier turns of the conversation.

3. Save the complete answer and its citations without editing

Preserve the answer before you navigate away, rewrite it or generate another version. This is the step where verbatim matters most.

1. Wait for the answer to finish. If it stops or comes back partial, record that state instead of calling it complete.
2. Save the exact prompt you submitted, plus any earlier conversation a follow-up depends on.
3. Use the interface's copy control and paste into a UTF-8 text file, keeping qualifying language, lists, tables and reference markers.
4. Save the cited sources separately, with the titles shown, the destination addresses and their order or markers.
5. Check that the saved copy has the first and last lines and every section.
6. If you regenerate the answer, treat the result as a new observation with its own ID.

Don't fix spelling, tidy punctuation, take out hedging, or ask another AI tool to restate the answer for the archive. A cleaned-up copy is no longer verbatim.

Pasted text may drop hyperlinks or the citation panel, so keep the searchable text plus a visual or native companion, and label each by how you got it. If something was visible but you couldn't save it, note that as an omission.

You're done when the saved text matches the displayed wording, the beginning and end are both there, and a reviewer can connect the text to the citations that were on screen.

Common mistake. Saving a summary in place of the answer. A short note is fine on a dashboard, but it isn't a verbatim record. Keep summaries and annotations in separate fields that point back to the untouched capture.

4. Add a visual record and the native export

Pair the searchable text with a record of what the interface actually showed. A screenshot alone can leave out content and is hard to search. A text file alone can lose the layout, the link destinations or the visible model label. Together they're stronger than either one, though neither one proves when the provider generated the answer.

Capture the prompt, answer and visible model label together. For a long answer, take overlapping screenshots named in order, or a full-page capture you've checked. If you print to PDF, open it and look for missing pages, clipped tables and absent citations. Keep original screenshots clean and put highlights, crops and redactions in separate derivative files. Save the native export where the service has one, keep the downloaded original before converting anything, and store any shared link as a backup locator only.

The options differ by engine, so this table summarizes what each one documents and where it falls short.

A few details are worth knowing before you rely on these. OpenAI's export guide says a ChatGPT export can take up to seven days, the download link expires 24 hours after you receive it, and it can't restore chats you already deleted. It also says self-serve export isn't available for Business or Enterprise workspaces, so open the ZIP and confirm your conversations are really in it. Sharing a Gemini conversation creates a public link to the entire conversation, so it isn't a good default for confidential material. Google's documentation doesn't describe a full export of AI Mode, so use the text, visual and metadata workflow here, and keep AI Mode, AI Overviews and Gemini Apps as separate values in your metadata.

You're done when the visual files cover the whole relevant answer, the native export opens, and the archive doesn't depend on a shared link still working.

5. Package each observation with structured metadata

Put all the files for one observation under one capture ID, and keep originals apart from derivatives. Here's one layout you could use, and it's a suggestion more than a standard.

ai-answer-archive/
  index.csv
  prompts/
    P001-v001.txt
  captures/
    2026/
      11/
        CAP-000001/
          metadata.json
          prompt.txt
          context.txt
          answer.verbatim.txt
          citations.json
          originals/
            screen-001.png
            provider-export.pdf
          derivatives/
            answer.search.txt
            review-copy.pdf
          manifest.sha256
          events.jsonl

Only include files that really exist, since a native export might be a ZIP or JSON instead of a PDF. Keep a whole provider export once in a restricted area and link your capture records to it.

Use one metadata record per answer observation, and a parent conversation or run ID to connect related ones. The fields from steps 1 to 4 are the core: identity (capture ID, prompt ID and version, exact prompt), source (engine, surface, model label, mode), time (UTC capture time, timestamp source, provider time), provenance (collector, method, any IDs the interface showed), context, file paths, capture status, omissions, the checksum manifest, and access and retention.

Here's the second place DeepSmith helps. The DeepSmith API is read-only and gives you the data already collected for your workspace. Its overview puts answers and exports under the visibility:read scope, and the pricing page describes raw visibility export through CSV or API. So one way to fill your archive is to pull the records through the documented export or read-only integration, keep the original file exactly as returned, and then map the fields that are actually there into your schema. Record your own archive timestamps and any missing values in separate fields. Reads don't spend credits. The public overview doesn't give an answer-specific response format, so check a sample export before you assume it carries the full answer text, an exact model ID or every field above. For more on where the data can leave the platform, exports and reporting hooks are covered in their own guide.

For the technical side, the API accepts a Bearer authorization header or an X-API-KEY header, and the limit is 120 requests per minute per workspace, shared across its keys. Going over returns an HTTP 429, which isn't a successful capture, so wait before you retry. Keep keys out of your capture files and screenshots.

You're done when a capture ID leads you to the exact prompt, answer, visual evidence and metadata, every referenced file exists, and imported files still show where they came from.

Common mistake. Putting every answer into one editable document, overwriting yesterday's files, or labeling a field you invented as if it were a native product field.

6. Build an index that searches metadata and answer text

Make the archive searchable without making the index the only copy of the evidence. A spreadsheet or database with one row per observation is enough to start. Include the capture ID, prompt ID, engine, surface, visible model, capture time, company, capture status and the package location.

Store the full answer in its preserved file. If your index also holds the answer text, treat that as a convenience for searching, not the authoritative original. You should be able to search by company, prompt ID and version, engine, surface, date range, model label, capture status, exact phrases in the answer, cited sources and capture ID.

A sheet of file links doesn't give you full-text search across the linked files, so use a repository whose text search you've tested, put the answer text in a searchable field, or keep a derived text index. Keep OCR output in a derivative file since it can contain errors.

Run these acceptance tests before you trust the index. Find a record by capture ID, find every observation of one prompt version on one engine in a chosen period, find a distinctive phrase from a saved answer, and open the complete original from the result. Then confirm a teammate with the right permissions can do the same.

You're done when those tests pass without the original AI account or a public conversation link. If you later want to judge the tone of what you've saved, that's a separate job, and there's a comparison of tools that show how AI describes your brand.

Common mistake. Assuming a folder name makes content searchable, relying only on OCR, or keeping a dashboard that can't open the underlying answer.

7. Protect originals, record checksums and keep recoverable copies

Make changes detectable and recovery possible. Limit who can edit or delete the original capture files, and give highlights, redactions, OCR and reformatted documents their own derivative location. Turn on version history or stronger write protection if your storage has it, but don't call ordinary read-only permissions immutable. Keep an event log of ingestion, copying and verification.

For fixity, which just means checking that stored bytes haven't changed, a practical choice is SHA-256 checksums on the original files. That's a recommendation for this workflow, and no source requires that exact algorithm. Record each file's path, the algorithm and the value. Hash the final captured files as early as you can, then recalculate and compare after any transfer or restore. The Library of Congress asks for fixity information early in ingestion, records for files and groups of files, and auditable logs of integrity checks. NIST's evidence preservation guidance recommends documenting the original source, hashing files and keeping more than one copy.

Keep a copy of the manifest somewhere separate from the files it describes, since someone who can swap both a file and its checksum leaves no trace. Different formats of the same answer have different bytes, so a screenshot, a Markdown export and a text copy each get their own hash.

Then keep more than one independently recoverable copy. A second folder in the same account with the same delete permissions isn't a strong arrangement, so a controlled working repository plus a separately administered backup is reasonable for a small marketing team, and the point is to test a restore and not just a sync.

Last, set access and retention. Use individual accounts, give people the least access they need, avoid public links for restricted material, and write down retention by purpose and company policy. None of the sources set a universal retention period for AI-answer logs, so don't invent a fixed number of years, and check deletion rules with whoever owns your internal policies. To share more widely, distribute a separate redacted copy and note what was redacted.

You're done when you can point to the preserved original, compare it to a protected checksum baseline, restore another copy and say who had access.

Common mistake. Overwriting originals during cleanup, calling synced copies backups without testing recovery, or saying that a checksum proves the answer is true or would be accepted as legal evidence. A matching checksum only shows the file matches what you recorded.

8. Repeat collection and prove that old records can be retrieved

To archive AI answers well over time, add new observations and test the archive instead of replacing its history. Pick a cadence that fits your question, and use the same prompt version and recorded conditions when you want a like-for-like comparison.

Give every new answer a new capture ID, even when a repeated prompt produces the same wording, because the time and context still differ. Keep failed runs and partial captures as their own states.

This is where the retrieval drill comes in. Pick an older capture and ask another authorized teammate to find the exact prompt and its context, the full saved answer, the visual or native companion, the engine, surface and capture time, the cited sources as captured, and the checksum baseline with its latest verification event, all without rerunning the prompt.

Then restore a backup copy and confirm it matches the recorded baseline.

DeepSmith helps with the day-to-day part. You can inspect collected answers by engine and over time, and coverage depends on the plan: Pro covers ChatGPT, Grow adds Perplexity, Scale adds Gemini, and Enterprise covers all ten engines. Treat that answer history as a working view and keep it separate from your independent archive, since it isn't a promise about how long answers are kept. If you're choosing among AI visibility tools for collection, ask each one how it exports the full answer. Comparisons by team type can narrow the list, like LLM monitoring tools that track responses across models, or the shortlist of tools a marketing team can run without an engineer. Agencies keeping client records can look at monitoring tools for agencies. Larger companies with stricter access rules can look at tools built for enterprise. Content teams can look at tools that tie mentions to pages.

You're done when the team can retrieve a specific historical answer without rerunning the prompt or relying on the original shared link.

Common mistake. Regenerating an answer to rebuild a missing record, keeping only the newest response, or treating a monitoring dashboard as a permanent archive.

Check one record end to end

Before you add more prompts, run the full workflow on one prompt and have a teammate retrieve it using only the index.

If you want tracked prompts running on a schedule with the full answers saved behind your visibility data, you can start the 7-day free trial and keep the independent archive from this guide alongside it.

Related guides

• How to Monitor Product-Level Mentions in ChatGPT: Track product-level mentions in ChatGPT with prompts and checks tied to each product.
• How to Run a GEO Check on a Page Before You Publish: Run a repeatable pre-publish check of a single page for answer-first structure, evidence, entities and markup.
• What an AI Overviews Analyzer Should Show: Features to Look For: Evaluate an AI Overviews analyzer by checking for features such as keyword level presence, cited source lists, history over time, location and device views, exports and competitor comparison.
• Allable Alternatives: 7 Best All-in-One AI Content Tools for 2026: A comparison of seven Allable alternatives (DeepSmith, Writesonic, Scalenut, Frase, Surfer, Semrush, Jasper) for teams wanting one platform across research, writing, SEO, and publishing, with pricing, an honest.
• Asklantern Alternatives: 8 Best AI Visibility Trackers for 2026: Compares eight AI visibility trackers a team can move to from Asklantern, including DeepSmith, Profound, Peec AI, OtterlyAI, Scrunch, Ahrefs Brand Radar and Semrush.