Collect AI answers and citations

Collect an answer from a specific AI engine and inspect the sources it returns.
Use this to research a topic or observe how an engine describes your brand.
You receive the answer and provider details to use in your own analysis.

Before you start

Connect to Scrappycoco. For the REST example,
create an API key and set SCRAPPYCOCO_API_KEY in your
shell. For CLI or MCP, complete sign-in in your client. Requests use your
Scrappycoco balance.

Ask your connected AI agent

Use Scrappycoco to collect ChatGPT's answer to “What products does Patagonia
sell?” Ask for sources, return the answer and citations, and identify missing
or unsupported information.

To collect answers from multiple engines, ask for a separate request to each
engine with the same prompt and locale. Review the actual answers before
drawing conclusions about brand visibility.

Choose an engine

These capabilities appear at the top level of the live catalog:

Inspect the live capability before running. Catalog inclusion does not guarantee
availability. If a route is unavailable, the catalog reports why.

curl https://api.scrappycoco.ai/api/v1/scrapers/web/ask_chatgpt \
  -H "X-API-Key: $SCRAPPYCOCO_API_KEY"

The web.ask_* capabilities keep the requested engine explicit. For example,
a failed Copilot request is reported as a failure; it does not switch to ChatGPT.
These routes use Cloro, whose identity, options, responses, and costs appear
in the execution details.

Run through REST

Save this as request.json. input.query is the prompt. Locale and output
settings belong under
provider_options, using the inspected schema.

{
  "source": "web",
  "capability": "ask_chatgpt",
  "input": {
    "query": "What products does Patagonia sell? Include links to sources.",
    "timeout_s": 180
  },
  "providers": ["cloro_chatgpt"],
  "provider_options": {
    "cloro_chatgpt": {
      "country": "US",
      "include": {"markdown": true}
    }
  }
}

curl --fail-with-body -sS \
  https://api.scrappycoco.ai/api/v1/scrapers/execute \
  -H "X-API-Key: $SCRAPPYCOCO_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  --data-binary @request.json

This returns records in the same response. Allow sufficient client timeout for
the engine to answer; input.timeout_s does not change your HTTP client's timeout.
For longer work, send the same body to POST /api/v1/scrapers/jobs and retrieve the
job. See REST integration.

For Copilot, change the capability to ask_copilot, the provider to
cloro_copilot, and the corresponding provider_options key. Use a separate
request for each engine. An ordered providers list is a fallback sequence,
not a request to collect answers from every engine.

Run through CLI or MCP

The CLI uses the same request file:

scrappycoco catalog inspect web.ask_chatgpt --json
scrappycoco run web.ask_chatgpt --file request.json --output answers.json --json

In MCP, inspect get_scraper with scraper_id: "web.ask_chatgpt", then call:

{
  "name": "run_scraper",
  "arguments": {
    "scraper_id": "web.ask_chatgpt",
    "input": {"query": "What products does Patagonia sell? Include links to sources."},
    "providers": ["cloro_chatgpt"],
    "provider_options": {"cloro_chatgpt": {"country": "US", "include": {"markdown": true}}},
    "idempotency_key": "<new-unique-key-for-this-request>"
  }
}

For batches of prompts to one engine, inspect input.items, batch_mode and
max_batch_size. Keep prompt, engine, locale, attempt and output attribution
together. Use the same prompts and locale when comparing engines.

Read the answer and sources

• records[].text and primary_format: the returned answer and representation.
• records[].outputs.citations: sources returned by the provider, or links
  recovered from answer text with metadata.citation_evidence_source provenance.
• records[].outputs.native_response: the complete provider envelope, including
  meaningful native fields beyond the common answer and citation shape.
• attempts, selected_provider and usage: what ran, any errors, and cost evidence.

An ok attempt is transport completion. Check for refusals, empty or truncated
answers, and whether the output actually answers your prompt. One observation is
a snapshot, not a general brand-visibility score. Scrappycoco does not score
brands or judge the answers for you.

Collect Google AI Overviews

For Google AI Overviews in search results, inspect web.search_web and the
cloro_google options instead. AI Overviews and Google AI Mode are distinct
observations; preserve that distinction in reports.

Use this selection in a web.search_web request:

{
  "providers": ["cloro_google"],
  "provider_options": {
    "cloro_google": {"include": {"aioverview": {"markdown": true}}}
  }
}

include.aioverview is an object, not a boolean. When an overview is returned,
read records[0].outputs.ai_overview; the native envelope is also preserved.
An organic search result alone is not evidence that Google displayed an overview.

Existing research integrations

Existing web.research calls with an explicit cloro_chatgpt, cloro_copilot,
or other Cloro answer-engine provider remain supported, with the same execution behavior
and billing rates. Prefer the named capabilities for new integrations because
they enforce the requested engine. Generic research or web search does not
become a ChatGPT observation merely because the query mentions ChatGPT.