---
title: "Track the Client Pages AI Crawlers Actually Fetch: An Edge-Log Tutorial"
description: "Set up edge logging for client domains, separate verified AI crawler requests from spoofed hits, and build a 30-day page-level report without changing application code."
url: "https://groas.com/post/tutorial-prove-which-client-pages-ai-bot"
image: "https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/81292e8a-7518-41c0-91bc-49dcf26a3ec3.png"
published: "2026-10-09T05:19:01.067Z"
modified: "2026-10-09T05:19:01.138Z"
---

October 9, 2026 · 9 min read

# Track the Client Pages AI Crawlers Actually Fetch: An Edge-Log Tutorial

[Alexander PerelmanHead Of Product @ groas](https://groas.com/author/alexander-perelman)[LinkedIn](https://www.linkedin.com/in/alexander-433793253/)

![Clay bouncer checks a queue all wearing 'GPTBot' tags; only one is genuine, the rest are fakes in moustaches and stacked trench coats.](https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/81292e8a-7518-41c0-91bc-49dcf26a3ec3.png)

In this article

1. [What you will have at the end](#what-you-will-have-at-the-end)
2. [Before you start: get DNS, edge, and log access](#before-you-start-get-dns-edge-and-log-access)
3. [Step 1: Route one pilot domain through the edge](#step-1-route-one-pilot-domain-through-the-edge)
4. [Step 2: Capture the AI agent strings you care about](#step-2-capture-the-ai-agent-strings-you-care-about)
5. [Step 3: Verify the requester before counting its hits](#step-3-verify-the-requester-before-counting-its-hits)
6. [Step 4: Label the type of request without claiming a citation](#step-4-label-the-type-of-request-without-claiming-a-citation)
7. [Step 5: Build the 30-day page rollup](#step-5-build-the-30-day-page-rollup)
8. [Step 6: Turn requests into an honest client report](#step-6-turn-requests-into-an-honest-client-report)
9. [Step 7: Repeat the pilot across client domains](#step-7-repeat-the-pilot-across-client-domains)

A ChatGPT screenshot proves that ChatGPT produced an answer once. It does not prove which of your client’s pages a crawler fetched to produce it.

I would rather start with the server-edge log: the requested URL, the response, and whether the supposed AI crawler was verified. That evidence is harder to decorate for a deck, which is precisely why it is useful. This tutorial builds a repeatable way to collect it across client domains without waiting for each client’s development team.

## What you will have at the end

You will have an edge-level request log and a **30-day, page-level rollup** of verified AI crawler fetches. The report will distinguish background crawls from requests made by user-facing agents, and keep unverified bot claims out of the headline numbers.

A verified fetch tells you an agent requested a page. It does **not**, by itself, prove that the page appeared in a live answer or earned a citation. Keep that distinction intact when the report reaches a client.

## Before you start: get DNS, edge, and log access

You need control of the client domain’s DNS, access to the edge proxy account, and a destination where you can query its HTTP request logs. The workflow below uses Cloudflare paths and fields as examples. Confirm that the client’s account exposes the logging and verified-bot fields you plan to use **before changing nameservers**.

You do not need to install a CMS plugin or change backend application code. You do need somewhere to send and query the records; DNS access alone will not produce a report. An edge proxy captures [structured HTTP request data](https://docs.airops.com/integrations/cloudflare-logpush) before the request reaches WordPress, Webflow, or Shopify.

Client-side analytics such as GA4 measure browser activity. AI crawlers generally request pages without firing the browser-based analytics tags you rely on for human visits, a gap also discussed in [community crawl analyses](https://www.reddit.com/r/aeo/comments/1nv941v/asking_the_model_why_it_cited_you_vs_checking/). Edge logs show the incoming request, including its URL, IP, headers, and response status. That makes them the right starting point for this job. **Do not use a zero in GA4 as a zero in crawler activity.**

![Diagram showing an AI crawler request reaching the edge proxy before the website and its browser analytics tags.](https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/0ffa4e8a-59c6-4646-a358-103f2203097f.png)

## Step 1: Route one pilot domain through the edge

Start with one client. A working pilot is worth more than 15 domains with broken redirects.

1. In Cloudflare, select **Websites > Add a Site**, enter the client’s domain, and review the imported DNS records against the existing records.
2. Under **SSL/TLS > Overview**, set the encryption mode to **Full (Strict)** if the origin is configured for it. Check the origin certificate and HTTPS behavior before switching live traffic.
3. At the domain registrar, replace the authoritative nameservers with the nameservers assigned to that site in Cloudflare.
4. Under **DNS > Records**, find the apex `A` record and the `www` `CNAME` record. Set **Proxy status** to **Proxied** for the hostnames you intend to log.
5. Once DNS changes have propagated, check the response headers:

```bash
curl -I https://clientdomain.com | grep -i 'cf-ray'
```

**Expected result:** A `CF-RAY` header appears, showing that the request passed through Cloudflare. Check the full response separately to confirm the page serves the intended content; the header alone does not promise a `200 OK`.

**Common mistake:** Turning on the proxy while **SSL/TLS > Overview** is set to **Flexible** and the origin redirects HTTP to HTTPS. That combination can create a redirect loop. Resolve the origin’s HTTPS setup first, then switch traffic. A telemetry project should not be the reason a client’s site stops loading.

## Step 2: Capture the AI agent strings you care about

Filter incoming requests by the agent names, but treat this as a **candidate list, not verification**. The names indicate what a requester claims to be.

- **OpenAI:** [Its bot documentation](https://developers.openai.com/docs/bots) distinguishes `GPTBot` from `ChatGPT-User`.
- **Anthropic:** [Its crawler guidelines](https://support.claude.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web-and-how-can-site-owners-block-the-crawler) list `ClaudeBot`, `Claude-SearchBot`, and `Claude-User`.
- **Perplexity:** Include `PerplexityBot`, but do not infer a specific live user prompt from that string alone.

Use this expression in the User-Agent filter for your log pipeline:

```regex
(GPTBot|ChatGPT-User|ClaudeBot|Claude-SearchBot|Claude-User|PerplexityBot)
```

**Expected result:** Requests claiming one of those agent identities enter your AI-crawler dataset, along with the requested path, response status, client IP, timestamp, and available verification field.

**Common mistake:** Adding `Google-Extended` to the User-Agent expression. [Google’s crawler documentation](https://developers.google.com/search/docs/crawling-indexing/overview-google-crawlers) describes it as a robots.txt control token, not an HTTP User-Agent. It will not produce the matches you expect.

![Table of AI crawler user-agent strings and the request categories used in this report.](https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/b6dc3345-3204-47b9-8ab8-6cfe8d375677.png)

## Step 3: Verify the requester before counting its hits

Any script can send a header that says `GPTBot`. That is why a User-Agent match belongs in a holding area, not in a client-facing total. [Crawler research from Human Security](https://www.humansecurity.com/resources/the-ultimate-list-of-crawlers-and-known-bots) documents bot impersonation; in [our analysis of edge telemetry](https://groas.com/post/76-of-our-ai-bot-traffic-couldn-t-be-ver), 76.5% of claimed AI bot hits failed verification. Report those requests as verified interest and your deck may be celebrating vulnerability scans.

In the edge logging configuration, include the available verified-bot field alongside the User-Agent and request fields. Depending on the Cloudflare setup, the relevant field may be `cf.bot_management.verified_bot` or `cf.client.bot`. Check the field names and values in the records your account actually exports; the query in Step 5 assumes you map the result to `verified_bot`.

[Cloudflare’s verified-bot documentation](https://developers.cloudflare.com/bots/concepts/bot/verified-bots/) describes its verification methods, including DNS checks and published IP information. Keep both verified and unverified candidate requests in storage so you can count spoof attempts, but **exclude unverified requests from crawler-activity totals**.

**Expected result:** Each candidate request has a verification value you can use in a query. A matching User-Agent with `verified_bot = false` does not enter your verified training or live-fetch counts.

**Common mistake:** Dropping unverified rows before storage and then trying to report how many you discarded. Retain them for the spoof column; just do not present them as AI engine activity.

## Step 4: Label the type of request without claiming a citation

A bulk crawl and a user-facing retrieval should not share one impressive-looking total. `GPTBot` and `ClaudeBot` belong in the background-crawl bucket. `ChatGPT-User` and `Claude-User` belong in the user-facing fetch bucket. `Claude-SearchBot` and `PerplexityBot` get separate search buckets here because their agent strings alone do not establish that a particular request fed a live answer.

Our [30-day audit of 11,793 AI bot hits on our homepage](https://groas.com/post/we-logged-30-days-of-ai-bots-on-our-own) is a useful reminder of why gross volume is a poor substitute for this split. The page requested matters as much as the count.

In your log-processing transform, apply this classification to the recorded `userAgent`, then write the resulting value as `bot_intent`:

```javascript
let botIntent = 'unknown';

if (userAgent.includes('ChatGPT-User') || userAgent.includes('Claude-User')) {
  botIntent = 'live_answer';
} else if (userAgent.includes('GPTBot') || userAgent.includes('ClaudeBot')) {
  botIntent = 'training_crawl';
} else if (userAgent.includes('Claude-SearchBot') || userAgent.includes('PerplexityBot')) {
  botIntent = 'search_index';
}
```

Use `live_answer` as a **reporting label for a user-facing agent fetch**, not a claim that you saw the finished answer. Apply the tag to candidate requests, then use the verification field when you count them.

**Expected result:** The logged AI-agent requests carry a `bot_intent` value of `live_answer`, `training_crawl`, `search_index`, or `unknown`.

**Common mistake:** Showing a client 4,000 `GPTBot` requests to old blog posts as proof that active buyers are finding the current offer. Those requests establish a different, narrower thing: the pages were fetched by a training crawler.

![Illustration of edge requests splitting into background crawl, search-index, and user-facing fetch categories.](https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/df19bfd9-039c-47f3-bc77-d1f3f4653358.png)

## Step 5: Build the 30-day page rollup

Send the request records to the destination you chose before the DNS switch, such as a queryable warehouse fed by Logpush. Map its exported field names to the names below: `ClientRequestURI`, `EdgeStartTimestamp`, `verified_bot`, `bot_intent`, `bot_family`, and `is_ai_crawler`. Do not paste a sample query into an unmapped schema and call the resulting error a crawler problem.

Run this query against the mapped table:

```sql
SELECT
  ClientRequestURI AS page_path,
  COUNTIF(bot_intent = 'training_crawl' AND verified_bot = true) AS verified_training_hits,
  COUNTIF(bot_intent = 'live_answer' AND verified_bot = true) AS verified_live_hits,
  COUNTIF(bot_intent = 'search_index' AND verified_bot = true) AS verified_search_hits,
  COUNTIF(verified_bot = false) AS spoofed_unverified_hits,
  ARRAY_AGG(DISTINCT bot_family) AS active_bots
FROM `edge_logs.client_http_requests`
WHERE EdgeStartTimestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
  AND is_ai_crawler = true
GROUP BY 1
ORDER BY verified_live_hits DESC, verified_training_hits DESC;
```

**Expected result:** One row per requested URI, with verified request counts split by category and a separate count of unverified claims. The first month’s report will cover only the days since logging began, even though the query asks for a trailing 30 days.

**Common mistake:** Presenting `/robots.txt`, `.ico` files, and `.png` files beside pricing and comparison pages as though all requests were content evaluation. Keep the raw rows, but filter system files and assets from the client-facing content view. Review the homepage separately, too: its traffic can bury the interior pages you are trying to inspect.

## Step 6: Turn requests into an honest client report

Put **verified interior-page fetches first**. Show the page, the agent category, and the response the agent received. Put unverified claims in their own column so the client can see why the gross number is not the headline.

Here is an illustrative layout, not a set of client results:

| Client page path    | Verified training hits | Verified user-facing hits | Unverified claims discarded | What to inspect                      |
| :------------------ | ---------------------: | ------------------------: | --------------------------: | :----------------------------------- |
| `/pricing`          |                    148 |                        39 |                         312 | Response and current pricing content |
| `/vs-competitor`    |                     94 |                        52 |                         140 | Comparison content and response      |
| `/integrations`     |                     61 |                        14 |                          88 | Feature detail and response          |
| `/blog/legacy-post` |                  1,240 |                         0 |                         510 | Background crawl only                |

**Expected result:** A client can tell which pages verified agents requested and which requests were merely claims made in a header. A `200 OK` user-facing fetch is stronger evidence of access than a screenshot. It is still not proof of a citation, a buyer, or revenue.

**Common mistake:** Treating zero hits as proof that a model never mentions the client. A model may answer without a fresh request to that page. Treat zero-hit pages as an audit list, not a verdict; check whether the important content is accessible and whether the response is the one you intended.

## Step 7: Repeat the pilot across client domains

![Four-step checklist for repeating edge logging setup across client domains.](https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/665cd655-7dcd-4664-bb6c-0b50ced0f751.png)

Once the pilot produces trustworthy rows, repeat the same sequence for domains 2 through 15:

1. **Route the domain:** Review its imported DNS records, confirm HTTPS behavior, then switch the intended hostnames to **Proxied**.
2. **Apply the same classification:** Reuse the User-Agent filter and `bot_intent` mapping. Confirm the verification field is available on that account rather than assuming the pilot’s schema carries over.
3. **Separate client data:** Send the domain’s records to the log destination and tag them with its `domain_id` so one client’s hits do not appear in another’s report.
4. **Run the first-day check:** Within 24 hours, query for incoming request rows, their verification values, and their response statuses. Do not expect a verified AI fetch on demand; confirm logging works before waiting for one.

**Expected result:** Each domain has its own queryable request history and the same report definitions. The repeatable part is the edge configuration and reporting workflow, not a promise that every client will receive crawler traffic on your schedule.

**Common mistake:** Scaling a pilot whose `200 OK` pages are actually redirects or challenge screens for crawlers. Check the response before you copy the setup 14 times.

For a roster of clients, manual log maintenance can become its own agency service disguised as a measurement project. If the next job is acting on what you learn across paid and organic search, [groas for agencies](https://groas.com/for-agencies) offers autonomous execution with human strategic ownership. Do not confuse that work with the edge report you just built: a request log measures access, while search performance still has to earn its result.

To verify this pipeline, find a verified `ChatGPT-User` or `Claude-User` request for an interior URL, confirm the domain and path, and inspect its HTTP response. **First change once it works:** fix any redirect or challenge that prevents that agent from receiving the intended page. Then read the 30-day rollup. The screenshot can wait.

## Frequently Asked Questions

### Why can't I just use GA4 to see when AI crawlers visit my site?

GA4 measures browser activity, and AI crawlers generally request pages without firing browser-based analytics tags. Edge logs capture the incoming request directly, including its URL, IP, headers, and response status, so they show crawler traffic that analytics never sees. A zero in GA4 should never be treated as zero crawler activity.

### Do I need to install a plugin or change my application code to log AI crawler requests?

No. The setup needs control of the domain's DNS, access to the edge proxy account, and a destination where you can query HTTP request logs. No CMS plugin or backend application code changes are required, because the edge proxy captures the request data before it reaches platforms like WordPress, Webflow, or Shopify.

### How can I tell real AI crawler traffic from fake bot headers?

A User-Agent string only states what a requester claims to be, so treat matches as candidates, not verification. Include the verified-bot field in your logging configuration, such as cf.bot_management.verified_bot or cf.client.bot in Cloudflare, and exclude unverified requests from crawler-activity totals. Keep the unverified rows in storage so you can count spoof attempts separately.

### Which user-agent strings should I filter for to capture AI crawler requests?

Filter for OpenAI's GPTBot and ChatGPT-User, Anthropic's ClaudeBot, Claude-SearchBot, and Claude-User, and Perplexity's PerplexityBot. Do not add Google-Extended to the User-Agent expression, because Google documents it as a robots.txt control token rather than an HTTP User-Agent, so it will not produce the matches you expect.

### Should a bulk crawl by GPTBot count the same as a ChatGPT-User request?

No. GPTBot and ClaudeBot belong in a background-crawl bucket, while ChatGPT-User and Claude-User are user-facing fetches. Claude-SearchBot and PerplexityBot get separate search buckets because their agent strings alone do not establish that a request fed a live answer. A bulk crawl of old blog posts should not be presented as evidence that buyers are viewing current offer pages.

### Does a verified AI crawler fetch mean my page was cited in an AI answer?

No. A verified fetch only proves that an agent requested the page. It does not prove the page appeared in a live answer or earned a citation. Keep that distinction intact when presenting results, and treat zero hits as an audit list rather than proof a model never mentions the site, since a model may answer without a fresh request.

### What should I exclude from the client-facing 30-day report?

Filter system files and assets such as /robots.txt, .ico files, and .png files out of the client-facing content view, and review the homepage separately because its traffic can bury interior pages. Also note that the first month's report covers only the days since logging began, even though the query asks for a trailing 30 days.

### What should I check before repeating the edge logging setup across more client domains?

Confirm that the pilot's 200 OK pages are actually serving content to crawlers and are not redirects or challenge screens, then copy the setup. For each new domain, reconfirm the verification field is available on that account, tag records with a domain_id so client data stays separate, and run a first-day check within 24 hours to confirm logging works.

## Pay For Results, Not For Hours

Businesses buy the outcome, agencies resell it, and groas answers for it either way.

[See If You Qualify](https://groas.typeform.com/to/xC1bQNUT)

## Structured data

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://graph.groas.com/entity/groas","name":"groas","url":"https://groas.com/","logo":{"@type":"ImageObject","url":"https://groas.com/icon-512.png","width":512,"height":512},"sameAs":["https://www.linkedin.com/company/groas/"]},{"@type":"WebSite","@id":"https://groas.com/#website","name":"groas","url":"https://groas.com/","inLanguage":"en-US","publisher":{"@id":"https://graph.groas.com/entity/groas"}},{"@type":"WebPage","@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#webpage","url":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot","name":"Track the Client Pages AI Crawlers Actually Fetch: An Edge-Log Tutorial","description":"Set up edge logging for client domains, separate verified AI crawler requests from spoofed hits, and build a 30-day page-level report without changing application code.","inLanguage":"en-US","isPartOf":{"@id":"https://groas.com/#website"},"about":{"@id":"https://graph.groas.com/entity/groas"},"primaryImageOfPage":{"@type":"ImageObject","url":"https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/81292e8a-7518-41c0-91bc-49dcf26a3ec3.png"},"breadcrumb":{"@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#breadcrumb"},"dateModified":"2026-10-09T05:19:01.138Z","mainEntity":{"@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#article"}},{"@type":"BreadcrumbList","@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://groas.com/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https://groas.com/blog"},{"@type":"ListItem","position":3,"name":"Track the Client Pages AI Crawlers Actually Fetch: An Edge-Log Tutorial","item":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot"}]},{"@type":"BlogPosting","@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#article","url":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot","mainEntityOfPage":{"@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#webpage"},"isPartOf":{"@id":"https://groas.com/blog#blog"},"headline":"Track the Client Pages AI Crawlers Actually Fetch: An Edge-Log Tutorial","description":"Set up edge logging for client domains, separate verified AI crawler requests from spoofed hits, and build a 30-day page-level report without changing application code.","datePublished":"2026-10-09T05:19:01.067Z","dateModified":"2026-10-09T05:19:01.138Z","image":{"@type":"ImageObject","url":"https://pub-87da24ecbbfc4c3bad6875f3aa013712.r2.dev/generated-images/81292e8a-7518-41c0-91bc-49dcf26a3ec3.png"},"author":{"@id":"https://groas.com/author/alexander-perelman#person"},"publisher":{"@id":"https://graph.groas.com/entity/groas"},"keywords":"verified, client, bot, requests, crawler, hits, pages, request","wordCount":1944,"inLanguage":"en-US"},{"@type":"Person","@id":"https://groas.com/author/alexander-perelman#person","name":"Alexander Perelman","jobTitle":"Head Of Product @ groas","description":"Ex Goldman Sachs and Ex Stanford Computer Science","image":"https://groas.com/media/blog/4f17cac3a81acc224cc1b2cfab8f94bbc295a3089d13e8421125771ef8d4064f.jpg","worksFor":{"@id":"https://graph.groas.com/entity/groas"},"sameAs":["https://www.linkedin.com/in/alexander-433793253/"]},{"@type":"FAQPage","@id":"https://groas.com/post/tutorial-prove-which-client-pages-ai-bot#faq","mainEntity":[{"@type":"Question","name":"Why can't I just use GA4 to see when AI crawlers visit my site?","acceptedAnswer":{"@type":"Answer","text":"GA4 measures browser activity, and AI crawlers generally request pages without firing browser-based analytics tags. Edge logs capture the incoming request directly, including its URL, IP, headers, and response status, so they show crawler traffic that analytics never sees. A zero in GA4 should never be treated as zero crawler activity."}},{"@type":"Question","name":"Do I need to install a plugin or change my application code to log AI crawler requests?","acceptedAnswer":{"@type":"Answer","text":"No. The setup needs control of the domain's DNS, access to the edge proxy account, and a destination where you can query HTTP request logs. No CMS plugin or backend application code changes are required, because the edge proxy captures the request data before it reaches platforms like WordPress, Webflow, or Shopify."}},{"@type":"Question","name":"How can I tell real AI crawler traffic from fake bot headers?","acceptedAnswer":{"@type":"Answer","text":"A User-Agent string only states what a requester claims to be, so treat matches as candidates, not verification. Include the verified-bot field in your logging configuration, such as cf.bot_management.verified_bot or cf.client.bot in Cloudflare, and exclude unverified requests from crawler-activity totals. Keep the unverified rows in storage so you can count spoof attempts separately."}},{"@type":"Question","name":"Which user-agent strings should I filter for to capture AI crawler requests?","acceptedAnswer":{"@type":"Answer","text":"Filter for OpenAI's GPTBot and ChatGPT-User, Anthropic's ClaudeBot, Claude-SearchBot, and Claude-User, and Perplexity's PerplexityBot. Do not add Google-Extended to the User-Agent expression, because Google documents it as a robots.txt control token rather than an HTTP User-Agent, so it will not produce the matches you expect."}},{"@type":"Question","name":"Should a bulk crawl by GPTBot count the same as a ChatGPT-User request?","acceptedAnswer":{"@type":"Answer","text":"No. GPTBot and ClaudeBot belong in a background-crawl bucket, while ChatGPT-User and Claude-User are user-facing fetches. Claude-SearchBot and PerplexityBot get separate search buckets because their agent strings alone do not establish that a request fed a live answer. A bulk crawl of old blog posts should not be presented as evidence that buyers are viewing current offer pages."}},{"@type":"Question","name":"Does a verified AI crawler fetch mean my page was cited in an AI answer?","acceptedAnswer":{"@type":"Answer","text":"No. A verified fetch only proves that an agent requested the page. It does not prove the page appeared in a live answer or earned a citation. Keep that distinction intact when presenting results, and treat zero hits as an audit list rather than proof a model never mentions the site, since a model may answer without a fresh request."}},{"@type":"Question","name":"What should I exclude from the client-facing 30-day report?","acceptedAnswer":{"@type":"Answer","text":"Filter system files and assets such as /robots.txt, .ico files, and .png files out of the client-facing content view, and review the homepage separately because its traffic can bury interior pages. Also note that the first month's report covers only the days since logging began, even though the query asks for a trailing 30 days."}},{"@type":"Question","name":"What should I check before repeating the edge logging setup across more client domains?","acceptedAnswer":{"@type":"Answer","text":"Confirm that the pilot's 200 OK pages are actually serving content to crawlers and are not redirects or challenge screens, then copy the setup. For each new domain, reconfirm the verification field is available on that account, tag records with a domain_id so client data stays separate, and run a first-day check within 24 hours to confirm logging works."}}]}]}
```