Mäta AI-citeringspåverkan: Analysdata, loggar och skrapning av svarspaneler

Mäta AI-citeringspåverkan: Analysdata, loggar och skrapning av svarspaneler

Introduktion

AI-driven upptäckt är nu uppdelad i flera mätlager. En person kan se ett företag citerat i ett AI-svar, klicka på en länk utan användbar hänvisare, besöka via en webbläsare som tar bort kampanjdata, eller läsa ett svar utan att klicka alls. Samtidigt kan en AI-bot begära företagets sida utan att representera en mänsklig besökare.

Ett användbart mätsystem måste därför separera fyra frågor:

1. Hämtades eller hämtades webbplatsen?
2. Citerades webbplatsen i ett AI-svar?
3. Besökte en person webbplatsen från det svaret?
4. Ledde det besöket till meningsfullt engagemang eller intäkter?

Från och med den 22 september 2026 förbättras förstapartsrapporteringen. Google Search Console tillhandahåller en prestandarapport för generativ AI för AI Overviews och AI Mode, inklusive exponeringar, sidor, länder, enheter och datum. Rapporten blev tillgänglig globalt den 31 augusti 2026. Googles rapport om generativ AI-prestanda (support.google.com)

Microsoft tillhandahåller också en AI Performance-rapport i Bing Webmaster Tools. Dess offentliga förhandsvisning rapporterar totala citeringar, citerade sidor, grundläggande frågor och citeringstrender över stödda Microsoft AI-upplevelser. Bing Webmaster Tools AI Performance (blogs.bing.com)

Dessa verktyg bör behandlas som auktoritativa för sina egna ytor, men de skapar inte ett komplett mätsystem över olika assistenter. Den rekommenderade metoden är att kombinera förstapartrapporter, serverloggar, kontrollerade spårningslänkar, analysdataexporter och schemalagda observationer av svarspaneler.

1. Varför AI-hänvisningsmätning är svårt

Traditionell webbanalys är starkt beroende av Referer-huvudet och kampanjparametrar. Båda kan saknas eller vara ofullständiga.

HTTP Referer-huvudet kan innehålla föregående sida, endast den föregående webbplatsens ursprung, eller inget värde alls. Webbläsarpolicyer för hänvisare kan avsiktligt begränsa eller ta bort den informationen. MDN Referrer-Policy dokumentation (developer.mozilla.org)

AI-system skapar ytterligare komplikationer:

• En assistent kan länka till en sida utan att skicka en igenkännbar hänvisare.
• En assistent kan använda en omdirigerande eller omskriven URL.
• En assistent kan hämta innehåll serversidan innan ett svar visas.
• En AI-bot kan besöka en sida utan att någon människa ser den.
• Svaret kan citera en kanonisk URL istället för den URL som ursprungligen hämtades.
• Svaret kan ändras beroende på plats, enhet, språk, tid eller personalisering.

Till exempel skiljer OpenAI mellan OAI-SearchBot för sökupptäckt, GPTBot för möjlig träningsanvändning och ChatGPT-User för användarinitierade åtgärder. Perplexity identifierar separat PerplexityBot och Perplexity-User. Anthropic identifierar ClaudeBot, Claude-SearchBot och Claude-User. Dessa förfrågningar bör inte kombineras till ett generiskt "AI-trafik"-nummer. OpenAI bot-dokumentation (openai.com) Perplexity bot-dokumentation (docs.perplexity.ai) Anthropic bot-dokumentation (support.anthropic.com)

Den centrala regeln är:

Botaktivitet är inte hänvisningstrafik, citeringssynlighet är inte trafik, och trafik är inte affärspåverkan.

2. Ramverket för mätning

Använd fem mätlager.

Rekommenderad källhierarki för sanningen

Använd den starkaste tillgängliga signalen för varje fråga:

1. Förstapartplattformsrapporter för exponeringar och citeringar.
2. Observationer av svarspaneler för synlighet på prompt-nivå och jämförelser med konkurrenter.
3. Omdirigeringsloggar för kontrollerade länkklick.
4. Webbanalys för sessioner, engagemang och konverteringar.
5. Serverloggar för bot- och hämtningsaktivitet.
6. Modellerade uppskattningar endast när direkta bevis saknas.

Kombinera inte alla signaler till ett enda nummer utan att bevara källa och konfidensnivå.

3. Grundläggande datamodell

Skapa ett datalager med separata tabeller för råa observationer och härledda mått.

panel_runs

En rad för varje prompt- och ytkontroll.

text run_id observed_at surface topic prompt_id query_text locale country device panel_present panel_type answer_hash raw_html_path screenshot_path collector_version status

panel_citations

En rad för varje länk som observerats i en svarspanel.

text run_id surface topic prompt_id cited_url cited_domain citation_position link_scope target_domain target_cited

ai_crawler_requests

Aggregerad serverloggdata.

text date bot_name bot_role path requests successful_requests error_requests unique_ip_count

shortener_clicks

En rad för varje kontrollerad länkbegäran.

text click_id occurred_at slug surface topic prompt_id asset_id referrer_host user_agent_family ip_hmac destination_path

ai_sessions

En normaliserad analysdata-tabell.

text session_id date surface topic prompt_id landing_page attribution_method confidence engaged engagement_time_seconds key_event revenue

confidence-fältet är viktigt. Rekommenderade värden är:

• A — Direkt: kontrollerat klick på kortlänk eller betrodd kampanjparameter.
• B — Stark: känd assistent-hänvisare eller verifierad användar-hämtningsförfrågan.
• C — Sannolik: bevis från kampanj eller målsida utan en komplett hänvisare.
• D — Modellerad: härledd från tidpunkt, panelobservationer eller aggregerade förändringar.

Rapportera A och B separat från C och D.

4. Metrikdefinitioner

Citeringsandel per ämne

Citeringsandel per ämne mäter hur ofta en måldomän förekommer bland de källor som observerats för ett ämne.

\[ \text{Citeringsandel}_{ämne}

\frac{\text{Antal citeringar av måldomänen}} {\text{Alla citeringsförekomster}} \]

Exempel:

• 100 totala citeringar observerade för "programvara för projekthantering"
• 12 citeringar pekar på din domän
• Citeringsandel per ämne = 12%

Detta mått mäter källandel, inte om ett svar innehöll din webbplats minst en gång.

Citeringsomfattning

Använd ett andra mått för närvaro på svarsnivå:

\[ \text{Citeringsomfattning}_{ämne}

\frac{\text{Antal svar som innehåller en målciteraring}} {\text{Antal svar där en panel fanns}} \]

Citeringsomfattning är ofta lättare för icke-tekniska målgrupper att förstå:

"Vår webbplats syntes i 34% av observerade AI-svar för detta ämne."

Citeringsposition

Registrera positionen för en citering inom svaret:

• 1 = första observerade källa
• 2 = andra observerade källa
• 3 = tredje observerade källa

Eftersom AI-gränssnitt ofta grupperar eller omordnar källor, behandla position som en beskrivande observation, inte en universell ranking.

Assistenthänvisningsfrekvens

Assistenthänvisningsfrekvens mäter andelen mänskliga webbplatssessioner som kan tillskrivas en AI-yta.

\[ \text{Assistenthänvisningsfrekvens}

\frac{\text{AI-tillskrivna mänskliga sessioner}} {\text{Alla mänskliga sessioner}} \]

Rapportera minst två versioner:

text Bekräftad Assistenthänvisningsfrekvens = A-konfidens AI-sessioner / alla mänskliga sessioner

Utökad Assistenthänvisningsfrekvens = A + B + C-konfidens AI-sessioner / alla mänskliga sessioner

Den bekräftade versionen är mer konservativ. Den utökade versionen är användbar för trendanalys men bör inte presenteras som fullt observerad trafik.

Använd inte panelkörningar som exponeringar

Om du skrapar 500 prompter betyder det inte att 500 personer såg dessa svar. Din skrapare mäter ett kontrollerat urval av svarstillstånd. Använd förstapartplattforms exponeringrapporter när de är tillgängliga.

Engagemang efter citering

Engagemang efter citering mäter om personer som kom via en AI-citering utförde en meningsfull åtgärd.

\[ \text{Engagemang efter citering}

\frac{\text{Engagerade AI-sessioner}} {\text{AI-tillskrivna sessioner}} \]

För Google Analytics 4 varar en engagerad session längre än 10 sekunder, inkluderar en nyckelhändelse, eller inkluderar minst två sid- eller skärmvisningar. Google Analytics dokumentation om engagemangsfrekvens (support.google.com)

Rapportera också:

text Engagemangstid efter citering = median engagerade sekunder per AI-session

Konverteringsfrekvens efter citering = AI-sessioner med en nyckelhändelse / AI-tillskrivna sessioner

Intäkt per session efter citering = intäkt från AI-sessioner / AI-tillskrivna sessioner

Median engagemangstid är vanligtvis stabilare än genomsnittlig engagemangstid eftersom ett litet antal mycket långa sessioner kan förvränga genomsnittet.

Ytterligare användbara mätvärden

AI-botars framgångsfrekvens

\[ \text{Botars framgångsfrekvens}

\frac{\text{AI-botbegäranden som returnerar 2xx eller 3xx}} {\text{AI-botbegäranden}} \]

Bryt ner detta per bot och sökväg. En hög citeringsminskning i kombination med en ökande bot-felprocent kan indikera ett problem med hosting, brandvägg eller robots-konfiguration.

Citerings-till-klick-frekvens

För kontrollerade svarspanelobservationer:

\[ \text{Observerad Citerings-till-klick-frekvens}

\frac{\text{Bekräftade klick på kortlänk}} {\text{Observerade målcitationer}} \]

Detta är inte en sann användares klickfrekvens om inte nämnaren representerar faktiska användarexponeringar. Märk det tydligt som ett observerat operationellt mått.

Citeringsaktualitet

Mät hur ofta den citerade URL:en speglar den aktuella sidversionen.

text Citeringsaktualitet = citerade sidor med nuvarande innehållshash / citerade sidor

Detta är användbart för dokumentation, prissättning, produkter och policysidor som ofta ändras.

5. Serverlogganalys

Konfigurera strukturerade åtkomstloggar

Strukturerade loggar är lättare att analysera än traditionella mellanslagseparerade loggar.

Exempel på Nginx-konfiguration:

nginx log_format ai_json escape=json '{' '"ts":"$time_iso8601",' '"remote_addr":"$remote_addr",' '"request":"$request",' '"status":$status,' '"bytes":$body_bytes_sent,' '"referer":"$http_referer",' '"user_agent":"$http_user_agent",' '"host":"$host"' '}';

access_log /var/log/nginx/ai-access.jsonl ai_json;

Lagr loggfilerna på en begränsad plats. Skicka inte råa IP-adresser till en generell analysdata-tabell om du inte har en tydlig operativ anledning.

Identifiera AI-förfrågningstyper

Separera minst:

text OpenAI:

• OAI-SearchBot
• ChatGPT-User
• GPTBot

Anthropic:

• Claude-SearchBot
• Claude-User
• ClaudeBot

Perplexity:

• PerplexityBot
• Perplexity-User

Sökmotorer:

• Googlebot
• Bingbot

Googles AI Search-funktioner använder generellt befintliga Google Search-genomsökningskontroller snarare än en separat universell "AI Overview bot." Google anger att Googlebot kontrollerar åtkomst för Sök, inklusive AI-funktioner. Googles AI-funktioner och webbplatser (developers.google.com)

User-agent-strängar kan förfalskas. För operationella beslut, kombinera user-agent-matchning med leverantörspublicerade IP-intervall eller verifierad omvänd DNS där tillgängligt. OpenAI och Perplexity publicerar IP-information för sina relevanta botar och hämtare. (openai.com)

Reproducerbar loggsammanfattare

Spara följande som ai_log_summary.py.

python #!/usr/bin/env python3

import csv import hashlib import hmac import json import os import re import sys from collections import Counter, defaultdict from datetime import datetime from urllib.parse import urlsplit

BOT_PATTERNS = { "OAI-SearchBot": ("openai", re.compile(r"\bOAI-SearchBot\b", re.I)), "ChatGPT-User": ("openai_user", re.compile(r"\bChatGPT-User\b", re.I)), "GPTBot": ("openai_training", re.compile(r"\bGPTBot\b", re.I)), "Claude-SearchBot": ("anthropic", re.compile(r"\bClaude-SearchBot\b", re.I)), "Claude-User": ("anthropic_user", re.compile(r"\bClaude-User\b", re.I)), "ClaudeBot": ("anthropic_training", re.compile(r"\bClaudeBot\b", re.I)), "PerplexityBot": ("perplexity", re.compile(r"\bPerplexityBot\b", re.I)), "Perplexity-User": ("perplexity_user", re.compile(r"\bPerplexity-User\b", re.I)), "Googlebot": ("google_search", re.compile(r"\bGooglebot\b", re.I)), "Bingbot": ("bing_search", re.compile(r"\bbingbot\b", re.I)), }

SECRET = os.environ.get("HMAC_SECRET", "replace-this-in-production").encode()

def hmac_ip(ip): return hmac.new(SECRET, ip.encode(), hashlib.sha256).hexdigest()[:16]

def classify_bot(user_agent): for bot_name, (role, pattern) in BOT_PATTERNS.items(): if pattern.search(user_agent or ""): return bot_name, role return None, None

def parse_path(request_line): try: parts = request_line.split() return urlsplit(parts[1]).path except Exception: return "/"

def main(input_path): totals = defaultdict(lambda: { "requests": 0, "success": 0, "errors": 0, "ips": set(), "paths": Counter(), })

with open(input_path, "r", encoding="utf-8") as source:
    for line in source:
        try:
            record = json.loads(line)
        except json.JSONDecodeError:
            continue

        bot_name, bot_role = classify_bot(record.get("user_agent", ""))
        if not bot_name:
            continue

        timestamp = record.get("ts", "")
        date = datetime.fromisoformat(
            timestamp.replace("Z", "+00:00")
        ).date().isoformat()

        status = int(record.get("status", 0))
        path = parse_path(record.get("request", ""))
        key = (date, bot_name, bot_role)

        totals[key]["requests"] += 1
        totals[key]["ips"].add(hmac_ip(record.get("remote_addr", "")))
        totals[key]["paths"][path] += 1

        if 200 <= status < 400:
            totals[key]["success"] += 1
        else:
            totals[key]["errors"] += 1

writer = csv.writer(sys.stdout)
writer.writerow([
    "date",
    "bot_name",
    "bot_role",
    "requests",
    "successful_requests",
    "error_requests",
    "unique_ip_count",
    "top_paths",
])

for (date, bot_name, bot_role), values in sorted(totals.items()):
    top_paths = values["paths"].most_common(10)
    writer.writerow([
        date,
        bot_name,
        bot_role,
        values["requests"],
        values["success"],
        values["errors"],
        len(values["ips"]),
        json.dumps(top_paths),
    ])

if name == "main": if len(sys.argv) != 2: print("Usage: python ai_log_summary.py /path/to/access.jsonl") sys.exit(1)

main(sys.argv[1])

Kör den med:

bash HMAC_SECRET='a-long-random-secret' \ python ai_log_summary.py /var/log/nginx/ai-access.jsonl \

data/ai_crawler_daily.csv

Detta ger operationella bevis om hämtningsaktivitet, inte mänsklig trafik.

6. Anpassade länkkortare för AI-riktade sammanfattningar

En förstaparts-länkkortare tillhandahåller en kontrollerad mätpunkt när du publicerar sammanfattningar eller källmaterial som kan refereras av AI-system.

Använd en domän du kontrollerar, till exempel:

text https://go.example.com/ai-docs

Destinationen bör inkludera kampanjparametrar som:

text utm_source=perplexity utm_medium=ai_answer utm_campaign=product_documentation utm_content=pricing_summary_v3

Google rekommenderar kampanjparametrar för att identifiera trafikkällor och kampanjer. Google Analytics kampanj-URL-dokumentation (support.google.com)

Rekommenderade länkfält

text surface topic prompt_id asset_id content_version destination_path

Lägg inte in personlig information, e-postadresser eller användares sökfrågor i länken. Kampanjidentifierare bör beskriva den publicerade tillgången, inte identifiera en person.

Viktiga begränsningar

En kort länk är ett kalibreringsverktyg, inte en universell lösning:

• Assistenten kan skriva om destinations-URL:en.
• Assistenten kan istället citera den kanoniska URL:en.
• Länken kan visas men aldrig klickas.
• En webbläsare eller integritetsverktyg kan ta bort hänvisaren.
• Vissa system kan hämta destinationen serversidan.
• En kort länk mäter inte användare som minns varumärket och återvänder senare.

Använd inte en kortare för att dölja destinationen, kringgå säkerhetssystem eller manipulera citeringar. Använd en tydlig omdirigering till en relevant, kanonisk sida.

Minimal förstaparts-länkkortare

Följande exempel använder FastAPI och SQLite. Skydda länkskapande endpoint med autentisering innan den används i produktion.

python

shortener.py

import hashlib import hmac import os import secrets import sqlite3 from datetime import datetime, timezone from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit

from fastapi import FastAPI, HTTPException, Request from fastapi.responses import RedirectResponse from pydantic import BaseModel

DB_PATH = os.environ.get("SHORTENER_DB", "shortener.db") HMAC_SECRET = os.environ.get( "HMAC_SECRET", "replace-this-in-production" ).encode()

ALLOWED_HOST = "www.example.com"

app = FastAPI()

def db(): connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row return connection

def init_db(): connection = db() connection.execute(""" CREATE TABLE IF NOT EXISTS links ( slug TEXT PRIMARY KEY, destination TEXT NOT NULL, surface TEXT NOT NULL, topic TEXT, prompt_id TEXT, asset_id TEXT, created_at TEXT NOT NULL ) """) connection.execute(""" CREATE TABLE IF NOT EXISTS clicks ( id INTEGER PRIMARY KEY AUTOINCREMENT, occurred_at TEXT NOT NULL, slug TEXT NOT NULL, surface TEXT, topic TEXT, prompt_id TEXT, referrer_host TEXT, user_agent TEXT, ip_hmac TEXT ) """) connection.commit() connection.close()

def append_query(url, params): parsed = urlsplit(url) query = dict(parse_qsl(parsed.query, keep_blank_values=True)) query.update(params) return urlunsplit(( parsed.scheme, parsed.netloc, parsed.path, urlencode(query), parsed.fragment, ))

def hash_ip(ip): return hmac.new( HMAC_SECRET, (ip or "").encode(), hashlib.sha256 ).hexdigest()[:16]

class LinkRequest(BaseModel): destination_path: str surface: str topic: str | None = None prompt_id: str | None = None asset_id: str | None = None

@app.on_event("startup") def startup(): init_db()

@app.post("/links") def create_link(payload: LinkRequest): destination = f"https://{ALLOWED_HOST}{payload.destination_path}"

if not payload.destination_path.startswith("/"):
    raise HTTPException(400, "destination_path must be a site-relative path")

slug = secrets.token_urlsafe(7).replace("_", "-").replace("/", "-")

target = append_query(destination, {
    "utm_source": payload.surface,
    "utm_medium": "ai_answer",
    "utm_campaign": "citation_measurement",
    "utm_content": payload.asset_id or "unspecified",
})

connection = db()
connection.execute("""
    INSERT INTO links
    (slug, destination, surface, topic, prompt_id, asset_id, created_at)
    VALUES (?, ?, ?, ?, ?, ?, ?)
""", (
    slug,
    target,
    payload.surface,
    payload.topic,
    payload.prompt_id,
    payload.asset_id,
    datetime.now(timezone.utc).isoformat(),
))
connection.commit()
connection.close()

return {"slug": slug, "url": f"https://go.example.com/{slug}"}

@app.get("/{slug}") def redirect(slug: str, request: Request): connection = db() row = connection.execute( "SELECT * FROM links WHERE slug = ?", (slug,) ).fetchone()

if not row:
    connection.close()
    raise HTTPException(404, "Unknown link")

referrer = request.headers.get("referer", "")
referrer_host = urlsplit(referrer).hostname or ""

connection.execute("""
    INSERT INTO clicks
    (occurred_at, slug, surface, topic, prompt_id,
     referrer_host, user_agent, ip_hmac)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""", (
    datetime.now(timezone.utc).isoformat(),
    slug,
    row["surface"],
    row["topic"],
    row["prompt_id"],
    referrer_host,
    request.headers.get("user-agent", "")[:300],
    hash_ip(request.client.host if request.client else ""),
))
connection.commit()
connection.close()

return RedirectResponse(row["destination"], status_code=302)

Kör den med:

bash pip install fastapi uvicorn uvicorn shortener:app --host 0.0.0.0 --port 8080

Använd en 302-omdirigering för mätlänkar så att webbläsare och mellansystem är mindre benägna att cachelagra omdirigeringen permanent.

7. Schemalagd skrapning av AI-svarspaneler

Panel-skrapning är användbart för att besvara frågor som förstapartanalyser kanske inte exponerar:

• Vilka konkurrerande källor citeras?
• Vilken sida citeras för en specifik prompt?
• Ändras svaret beroende på land eller enhet?
• Förekommer citeringen i svaret, källlistan eller båda?
• Hur stabilt är svaret över tid?
• Citerar assistenten en kort länk eller den kanoniska URL:en?

Skrapning måste dock göras försiktigt.

Regler för ansvarsfull insamling

1. Föredra ett officiellt API, licensierad sökdataleverantör eller förstapartsrapport.
2. Granska leverantörens villkor innan du automatiserar förfrågningar.
3. Respektera robots-instruktioner där det är tillämpligt.
4. Kringgå inte CAPTCHA:s, inloggningshinder, hastighetsbegränsningar eller bot-skydd.
5. Använd en liten, fast promptuppsättning.
6. Kör med låg frekvens.
7. Spara svaret och tidsstämpeln så att resultaten kan granskas.
8. Stoppa när en leverantör returnerar en utmaning eller ett nekad åtkomst-svar.

Protokoll för exkludering av robotar är en preferensmekanism för botar, inte ett säkerhetssystem. Det auktoriserar inte åtkomst till skyddat innehåll. RFC 9309: Protokoll för exkludering av robotar (rfc-editor.org)

Bygg ett prompt-manifest

csv prompt_id,topic,query,locale,surface,target_domain pm_001,project-management,"best project management software for remote teams",en-US,google,example.com pm_001,project-management,"best project management software for remote teams",en-US,bing,example.com pm_002,analytics,"how to measure AI referral traffic",en-US,google,example.com

Håll prompterna stabila. Om prompterna ändras blir trendjämförelser mindre tillförlitliga.

Lagra även:

• land
• språk
• enhetstyp
• webbläsarversion
• promptversion
• innehållsversion
• insamlingstid i UTC

Google noterar att AI Overview och AI Mode-svar kan variera eftersom de använder olika system och kan använda relaterade sökningar eller "query fan-out." Googles AI-funktioner och webbplatsdokumentation (developers.google.com)

Playwright insamlingsskript

Följande skript är ett allmänt forskningsverktyg. Det registrerar den renderade sidan, skärmbilden, sidlänkar och svarstext. Det kringgår avsiktligt inte utmaningar eller försöker besegra åtkomstkontroller.

python

scrape_panels.py

import asyncio import csv import hashlib import json import os import re from datetime import datetime, timezone from pathlib import Path from urllib.parse import quote_plus, urljoin, urlsplit

from playwright.async_api import async_playwright

DATA_DIR = Path("data/panels") DATA_DIR.mkdir(parents=True, exist_ok=True)

SURFACE_URLS = { "google": "https://www.google.com/search?q={query}&hl=en&gl=us", "bing": "https://www.bing.com/search?q={query}&setlang=en-us", }

PANEL_MARKERS = { "google": ["AI Overview", "AI Mode"], "bing": ["Copilot", "Generative search"], }

BLOCK_MARKERS = [ "captcha", "unusual traffic", "verify you are human", "access denied", ]

def clean_text(value): return re.sub(r"\s+", " ", value or "").strip()

def host_matches(url, target_domain): host = (urlsplit(url).hostname or "").lower() target = target_domain.lower().lstrip("www.") return host == target or host.endswith("." + target)

def page_hash(text): normalized = clean_text(text).encode("utf-8") return hashlib.sha256(normalized).hexdigest()

async def collect_one(page, row): surface = row["surface"] query = row["query"] target_domain = row["target_domain"]

search_url = SURFACE_URLS[surface].format(
    query=quote_plus(query)
)

await page.goto(
    search_url,
    wait_until="domcontentloaded",
    timeout=45_000,
)
await page.wait_for_timeout(2500)

text = await page.locator("body").inner_text()
lowered = text.lower()

if any(marker in lowered for marker in BLOCK_MARKERS):
    return {
        **row,
        "observed_at": datetime.now(timezone.utc).isoformat(),
        "status": "blocked_or_challenged",
        "panel_present": False,
        "links": [],
    }

links = await page.locator("a").evaluate_all("""
    anchors => anchors.map(a => ({
        href: a.href || "",
        text: (a.innerText || "").trim()
    })).filter(x => x.href)
""")

panel_present = any(
    marker.lower() in lowered
    for marker in PANEL_MARKERS.get(surface, [])
)

observed_at = datetime.now(timezone.utc)
run_id = hashlib.sha256(
    f"{surface}|{row['prompt_id']}|{observed_at.isoformat()}".encode()
).hexdigest()[:20]

html_path = DATA_DIR / f"{run_id}.html"
screenshot_path = DATA_DIR / f"{run_id}.png"

await page.screenshot(path=str(screenshot_path), full_page=True)
html_path.write_text(await page.content(), encoding="utf-8")

output_links = []
for position, link in enumerate(links, start=1):
    output_links.append({
        "href": urljoin(search_url, link["href"]),
        "text": clean_text(link["text"])[:300],
        "position": position,
        "target_cited": host_matches(
            link["href"],
            target_domain
        ),
    })

return {
    **row,
    "run_id": run_id,
    "observed_at": observed_at.isoformat(),
    "status": "ok",
    "panel_present": panel_present,
    "answer_hash": page_hash(text),
    "answer_text": clean_text(text)[:50_000],
    "html_path": str(html_path),
    "screenshot_path": str(screenshot_path),
    "link_scope": "page_fallback",
    "links": output_links,
}

async def main(manifest_path): rows = [] with open(manifest_path, newline="", encoding="utf-8") as source: rows = list(csv.DictReader(source))

output_path = DATA_DIR / (
    datetime.now(timezone.utc).strftime("%Y-%m-%d") + ".jsonl"
)

async with async_playwright() as playwright:
    browser = await playwright.chromium.launch(headless=True)
    context = await browser.new_context(
        locale="en-US",
        timezone_id="UTC",
    )
    page = await context.new_page()

    with open(output_path, "w", encoding="utf-8") as output:
        for row in rows:
            try:
                result = await collect_one(page, row)
            except Exception as exc:
                result = {
                    **row,
                    "observed_at": datetime.now(timezone.utc).isoformat(),
                    "status": f"error:{type(exc).__name__}",
                    "panel_present": False,
                    "links": [],
                }

            output.write(json.dumps(result) + "\

") output.flush()

            # Keep request volume low.
            await asyncio.sleep(8)

    await browser.close()

if name == "main": asyncio.run(main("prompts.csv"))

Installera och kör:

bash pip install playwright playwright install chromium python scrape_panels.py

Schemalägg det med ett lås så att två körningar inte kan överlappa varandra:

cron 15 3 * * * flock -n /tmp/ai-panel.lock \ /usr/bin/python3 /opt/ai-measure/scrape_panels.py

Förbättra noggrannheten med yt-adaptrar

Fallbacks-skriptet registrerar länkar på sidnivå. Detta är användbart för upptäckt men kan inkludera vanliga sökresultatlänkar. För produktionsanvändning:

• Använd ett licensierat svarspanel-API när det är tillgängligt.
• Skapa en separat väljar-adapter för varje yta.
• Lagra väljarversionen.
• Lagra rå HTML och en skärmbild.
• Markera varje post med link_scope = "panel_selector" eller link_scope = "page_fallback".

Beräkna endast citeringsandel från panel_selector-data när du på ett tillförlitligt sätt kan identifiera panelen. Håll fallback-observationer i en separat utforskande rapport.

8. Google Analytics och BigQuery-integration

Google Analytics 4 kan exportera råa händelsedata till BigQuery. Dagliga exporter ger stabila tabeller som events_YYYYMMDD; streamingexporter är användbara för nära realtidsövervakning men kan vara ofullständiga tills den dagliga tabellen är färdigställd. Google Analytics BigQuery Export (support.google.com)

En förenklad sessionsfråga kan se ut så här:

sql WITH page_events AS ( SELECT event_date, user_pseudo_id,

(
  SELECT value.int_value
  FROM UNNEST(event_params)
  WHERE key = 'ga_session_id'
) AS session_id,

(
  SELECT value.string_value
  FROM UNNEST(event_params)
  WHERE key = 'page_location'
) AS page_location,

(
  SELECT value.string_value
  FROM UNNEST(event_params)
  WHERE key = 'session_engaged'
) AS session_engaged,

event_name

FROM PROJECT.analytics_PROPERTY.events_* WHERE _TABLE_SUFFIX BETWEEN '20260901' AND '20260921' ),

session_rollup AS ( SELECT event_date, user_pseudo_id, session_id,

MAX(
  CASE
    WHEN REGEXP_CONTAINS(
      LOWER(page_location),
      r'[?&]utm_medium=ai_answer'
    )
    THEN 1 ELSE 0
  END
) AS ai_session,

MAX(
  CASE
    WHEN session_engaged = '1'
    THEN 1 ELSE 0
  END
) AS engaged_session,

MAX(
  CASE
    WHEN event_name IN ('purchase', 'generate_lead', 'sign_up')
    THEN 1 ELSE 0
  END
) AS key_event

FROM page_events GROUP BY event_date, user_pseudo_id, session_id )

SELECT event_date, COUNTIF(ai_session = 1) AS ai_sessions, COUNTIF(ai_session = 1 AND engaged_session = 1) AS engaged_ai_sessions, COUNTIF(ai_session = 1 AND key_event = 1) AS ai_key_events, SAFE_DIVIDE( COUNTIF(ai_session = 1 AND engaged_session = 1), COUNTIF(ai_session = 1) ) AS post_citation_engagement_rate FROM session_rollup GROUP BY event_date ORDER BY event_date;

För en mogen implementering, lägg till surface, topic och prompt_id till kampanjstrukturen eller koppla dem från klick-tabellen för länkkortaren.

Skapa inte en dimension med hög kardinalitet för varje enskild användare eller session. Google varnar för att alltför många anpassade dimensioner med hög kardinalitet kan minska rapporteringskvaliteten. Google Analytics anpassade dimensioner och mätvärden (support.google.com)

9. Dashboard-design

En praktisk instrumentpanel bör innehålla fem vyer.

Sammanfattning för ledningen

Visa:

• Citeringsandel per ämne
• Citeringsomfattning per ämne
• Bekräftad assistenthänvisningsfrekvens
• Utökad assistenthänvisningsfrekvens
• Engagemang efter citering
• AI-botars framgångsfrekvens
• AI-tillskrivna nyckelhändelser eller intäkter

Trend för citeringsandel

Linjediagram:

text Datum × Ämne × Yta

Visa båda:

• förekomster av citeringar av måldomänen
• alla observerade citeringsförekomster

Assistenttrafiktratt

text Observerade citeringar ↓ Klick på kontrollerade länkar ↓ AI-tillskrivna sessioner ↓ Engagerade AI-sessioner ↓ Nyckelhändelser

Varje steg bör visa sin attribution-konfidens.

Bot-status

Tabell per bot:

text bot_name requests successful_requests error_rate unique_ip_count top_paths

Varna när:

• felprocenten överstiger 2 procent
• en bot plötsligt försvinner
• en tidigare tillgänglig innehållssektion returnerar 403 eller 429
• bot-förfrågningar koncentreras till en oavsiktlig privat sökväg

Tabell för innehållsmöjligheter

Rankningssidor och ämnen efter:

text hög citeringsandel + låg hänvisningsfrekvens höga exponeringar + låg citeringsomfattning högt engagemang + låg citeringssynlighet höga botfel + hög affärsmässiga betydelse

Dessa kombinationer ger vanligtvis bättre beslut än att bara titta på trafikvolym.

Minimal Streamlit-instrumentpanel

Spara som dashboard.py.

python import glob import json from pathlib import Path

import pandas as pd import streamlit as st

st.set_page_config( page_title="AI Citation Impact", layout="wide", )

@st.cache_data(ttl=300) def load_panel_rows(): rows = []

for filename in glob.glob("data/panels/*.jsonl"):
    with open(filename, encoding="utf-8") as source:
        for line in source:
            record = json.loads(line)

            run_id = record.get("run_id")
            for link in record.get("links", []):
                hostname = link.get("href", "").split("/")[2]
                rows.append({
                    "run_id": run_id,
                    "observed_at": record.get("observed_at"),
                    "surface": record.get("surface"),
                    "topic": record.get("topic"),
                    "prompt_id": record.get("prompt_id"),
                    "panel_present": record.get("panel_present"),
                    "target_domain": record.get("target_domain"),
                    "cited_domain": hostname,
                    "target_cited": link.get("target_cited", False),
                    "position": link.get("position"),
                    "link_scope": record.get("link_scope"),
                })

return pd.DataFrame(rows)

panels = load_panel_rows()

st.title("AI Citation Impact Dashboard")

if panels.empty: st.warning("No panel observations found.") st.stop()

panels["date"] = pd.to_datetime( panels["observed_at"], errors="coerce" ).dt.date

citation_share = ( panels.groupby("topic") .apply( lambda group: group["target_cited"].sum() / max(len(group), 1) ) .reset_index(name="citation_share") )

coverage = ( panels.groupby(["topic", "run_id"], dropna=False) .agg( panel_present=("panel_present", "max"), target_cited=("target_cited", "max"), ) .reset_index() )

coverage = ( coverage[coverage["panel_present"] == True] .groupby("topic") .apply(lambda group: group["target_cited"].mean()) .reset_index(name="citation_coverage") )

col1, col2 = st.columns(2)

with col1: st.subheader("Citation Share by Topic") st.dataframe(citation_share, use_container_width=True) st.bar_chart( citation_share.set_index("topic")["citation_share"] )

with col2: st.subheader("Citation Coverage by Topic") st.dataframe(coverage, use_container_width=True) st.bar_chart( coverage.set_index("topic")["citation_coverage"] )

st.subheader("Citation Position") st.dataframe( panels.groupby(["topic", "surface"], dropna=False) .agg( citations=("target_cited", "sum"), median_position=("position", "median"), observations=("run_id", "nunique"), ) .reset_index(), use_container_width=True, )

st.subheader("Daily Observations") daily = ( panels.groupby(["date", "surface"], dropna=False) .agg( citations=("target_cited", "sum"), observed_links=("cited_domain", "count"), ) .reset_index() )

st.line_chart( daily.pivot( index="date", columns="surface", values="citations" ).fillna(0) )

Kör den med:

bash pip install streamlit pandas streamlit run dashboard.py

För produktion, ladda normaliserade tabeller till DuckDB, BigQuery, Snowflake eller PostgreSQL istället för att läsa råa filer direkt.

10. Kvalitetskontroller

Ett mätsystem kan producera exakt utseende men missvisande siffror. Lägg till dessa kontroller.

Separera botar från människor

Räkna aldrig OAI-SearchBot, GPTBot, ClaudeBot eller PerplexityBot som mänskliga sessioner. Dessa är signaler från botar eller hämtningar.

Bevara råa bevis

För varje panelkörning, behåll:

• rå HTML
• skärmbild
• svarstext
• tidsstämpel
• webbläsar- och samlarversion
• prompt och lokalisering
• svarshash

Detta gör det möjligt att förklara varför ett mått ändrades.

Spåra panelens frånvaro

En saknad AI-panel är inte samma sak som ett svar utan din citering.

Använd:

text panel_not_present panel_present_no_target panel_present_target_cited blocked_or_challenged collection_error

Kontrollera samplingsbias

En schemalagd skrapning påverkas av:

• plats
• enhet
• språk
• tid
• personalisering
• webbläsarstatus
• promptens formulering

Använd en fast kärnuppsättning av prompter och en roterande uppsättning utforskande prompter. Håll de två grupperna separata i rapporter.

Undvik falsk precision

Rapportera konfidensintervall eller minsta sampelstorlekar för små ämnesgrupper. Ett ämne med tre observationer bör inte jämföras direkt med ett ämne som innehåller 300 observationer.

Jämför lika med lika

När du jämför ytor, håll konstant:

• prompt
• lokalisering
• land
• enhet
• insamlingstimme
• regler för måldomän
• version av citeringsparser

11. Rekommenderad utrullningsplan

Vecka 1: Instrumentering

• Konfigurera strukturerade serverloggar.
• Skapa botregistret.
• Skapa länkkortare-domänen.
• Lägg till regler för kampanjnamngivning.
• Definiera ämnestaxonomin.
• Aktivera Google Analytics 4 BigQuery-export.

Vecka 2: Kontrollerade länkar

• Publicera fem till tio spårade sammanfattningar.
• Skapa länkar för olika ämnen och innehållsversioner.
• Validera omdirigeringsloggar mot analyssessioner.
• Bekräfta att ingen personlig information hamnar i URL:er eller analysparametrar.

Vecka 3: Panelobservationer

• Skapa ett prompt-manifest.
• Börja med två ytor och 20 till 50 stabila prompter.
• Kör en gång per dag.
• Spara skärmbilder och HTML.
• Mät insamlingsfel separat från citeringens frånvaro.

Vecka 4: Instrumentpanel och styrning

• Bygg instrumentpaneler för ämnen och ytor.
• Lägg till bot-statusvarningar.
• Definiera konfidensregler.
• Jämför förstapartrapporter med panelobservationer.
• Dokumentera policyer för lagring, åtkomst och radering.

Slutsats

AI-citeringsmätning bör byggas som ett fler-signalstillskrivningssystem, inte som en enkel hänvisningsrapport.

Den mest tillförlitliga ramen kombinerar:

• Googles och Bings förstapartsrapporter för synlighet
• serverloggar för bot- och hämtningsaktivitet
• förstaparts-kortlänkar för kontrollerad klickmätning
• schemalagda, kompatibla observationer av svarspaneler
• analys- och konverteringsdata för nedströmsvärde

De tre viktigaste mätvärdena är:

1. Citeringsandel per ämne — hur stor del av det observerade källutrymmet som tillhör din domän.
2. Assistenthänvisningsfrekvens — hur mycket mänsklig trafik som kan tillskrivas AI-ytor.
3. Engagemang efter citering — om AI-hänvisade besökare utför meningsfulla åtgärder.

Systemet blir användbart när varje nummer inkluderar dess yta, tidsperiod, nämnare, attribueringsmetod och konfidensnivå. Denna disciplin förhindrar att bot-träffar misstas för användare, att skrapade svar misstas för exponeringar och att citeringar misstas för affärsresultat.