Which model answers ChatGPT now, and does it still cite my site inline?

curl https://api.querying.ai/v1/chatgpt-model

#!/usr/bin/env python3
"""Print which model answers logged-out ChatGPT now and what changed at the last switch. No API key."""
import json
import sys
from urllib.request import urlopen

URL = "https://api.querying.ai/v1/chatgpt-model"
SHARES = ("citationPills", "entities", "shopping", "inlineProducts", "map")
AVERAGES = ("inlineSourcesPerAnswer", "sourcesPerAnswer", "searchesPerAnswer")


def main():
    with urlopen(URL, timeout=30) as response:
        board = json.load(response)["data"]
    current = board["current"]
    print(f"Default model: {current['model']} ({current['share']}% of the last 24 hours' answers)")
    print(f"Default since: {current['since']}")
    eras = board["eras"]
    if len(eras) < 2:
        return 0
    before, after = eras[-2], eras[-1]
    print(f"\n{'surface':<24}{before['model']:>10}{after['model']:>10}")
    for name in SHARES + AVERAGES:
        old, new = before["surfaces"].get(name), after["surfaces"].get(name)
        unit = "%" if name in SHARES else ""
        print(f"{name:<24}{str(old) + unit:>10}{str(new) + unit:>10}")
    return 0


if __name__ == "__main__":
    sys.exit(main())

Default model: gpt-6 (99.8% of the last 24 hours' answers)
Default since: 2026-10-09T07:00:00.000Z

surface                    gpt-5-6     gpt-6
citationPills                91.2%     22.8%
entities                     63.7%     81.7%
shopping                     24.8%      3.9%
inlineProducts               20.4%      4.1%
map                           1.7%      0.5%
inlineSourcesPerAnswer        2.93      0.71
sourcesPerAnswer             16.74     18.35
searchesPerAnswer             1.35      1.19

#!/usr/bin/env python3
"""Ask ChatGPT your own prompts and check which model answered and where your site is cited."""
import argparse
import json
import os
import sys
import time
from urllib.error import HTTPError
from urllib.parse import quote, urlsplit
from urllib.request import Request, urlopen

BASE_URL = "https://api.querying.ai"


def call(method, path, api_key, payload=None):
    data = None if payload is None else json.dumps(payload).encode("utf-8")
    request = Request(BASE_URL + path, data=data, method=method, headers={
        "Authorization": "Bearer " + api_key, "Content-Type": "application/json"})
    while True:
        try:
            with urlopen(request, timeout=30) as response:
                return json.load(response)
        except HTTPError as error:
            if error.code not in (429, 503):  # 429: plan concurrency; 503: queue busy
                raise RuntimeError(f"{method} {path} returned HTTP {error.code}") from error
            wait = error.headers.get("Retry-After", "")
            time.sleep(int(wait) if wait.isdigit() else 5)


def on_domain(url, domain):
    host = (urlsplit(url if "//" in url else "//" + url).hostname or "").casefold().rstrip(".")
    return host == domain or host.endswith("." + domain)


def read_answer(prompt, task_id, response, domain):
    """One row per answer, counted the way the public tracker counts."""
    pills = response.get("citationPills") or []
    sources = response.get("sources") or []
    inline_urls = {pill["url"] for pill in pills if isinstance(pill.get("url"), str)}
    row = {"task_id": task_id, "prompt": prompt, "model": response.get("model") or "unknown",
           "inline_citations": bool(pills), "inline_sources": len(inline_urls),
           "panel_sources": len(sources)}
    if domain:
        inline = any(on_domain(url, domain) for url in inline_urls)
        listed = any(on_domain(s.get("url", ""), domain) for s in sources if isinstance(s, dict))
        row["your_site"] = "inline" if inline else "panel only" if listed else "not cited"
    return row


def collect(api_key, prompts, country, domain, max_in_flight):
    waiting, running, rows = list(prompts), {}, []
    while waiting or running:
        while waiting and len(running) < max_in_flight:
            body = {"taskType": "CHATGPT", "payload": {"prompt": waiting[0], "country": country}}
            task = call("POST", "/v1/async/task", api_key, body)["task"]
            running[task["id"]] = waiting.pop(0)
        for task_id, prompt in list(running.items()):
            result = call("GET", "/v1/async/task/" + quote(task_id, safe=""), api_key)
            status = result["task"]["status"]
            if status in ("QUEUED", "PROCESSING"):
                continue
            del running[task_id]
            if status == "COMPLETED":
                rows.append(read_answer(prompt, task_id, result["response"], domain))
            else:
                rows.append({"task_id": task_id, "prompt": prompt, "status": status})
            print(f"{len(rows)}/{len(prompts)} {status}: {prompt}", file=sys.stderr)
        if running:
            time.sleep(4)
    return rows


def summarize(rows):
    by_model = {}
    for row in rows:
        if "model" in row:
            by_model.setdefault(row["model"], []).append(row)
    summary = {}
    for model, group in by_model.items():
        n = len(group)
        summary[model] = {
            "answers": n,
            "inline_citation_share": round(100 * sum(r["inline_citations"] for r in group) / n, 1),
            "inline_sources_per_answer": round(sum(r["inline_sources"] for r in group) / n, 2),
            "panel_sources_per_answer": round(sum(r["panel_sources"] for r in group) / n, 2),
        }
        if "your_site" in group[0]:
            for place in ("inline", "panel only", "not cited"):
                summary[model]["your_site_" + place.replace(" ", "_")] = sum(r["your_site"] == place for r in group)
    return summary


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("prompts", help="Text file with one prompt per line")
    parser.add_argument("--domain", help="Your site, for example example.com; subdomains count too")
    parser.add_argument("--country", default="US")
    parser.add_argument("--max-in-flight", type=int, default=2, help="Match your plan's concurrency")
    args = parser.parse_args()
    api_key = os.environ.get("QUERYING_API_KEY")
    if not api_key:
        print("Set QUERYING_API_KEY first", file=sys.stderr)
        return 1
    with open(args.prompts, encoding="utf-8") as handle:
        prompts = [line.strip() for line in handle if line.strip()]
    domain = args.domain.casefold().rstrip(".") if args.domain else None
    rows = collect(api_key, prompts, args.country, domain, args.max_in_flight)
    print(json.dumps({"answers": rows, "by_model": summarize(rows)}, indent=2))
    return 0


if __name__ == "__main__":
    sys.exit(main())

export QUERYING_API_KEY='<your-key>'
python3 check_chatgpt_citations.py prompts.txt --domain example.com --country US > citations.json