> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Assistants connect to Parse over MCP at [https://agent.parse.gl/mcp](https://agent.parse.gl/mcp) (Streamable HTTP). With no sign-in it answers from Parse's public view (the numbers parse.gl's public pages show, up to 5 rows a list), starting with `check_brand`. Signed in with Parse, or sent a workspace key (`parse_mcp_…`), it works in the person's workspace, starting with `get_brief`. Scripts call the same tools over REST at `https://agent.parse.gl/v1/tools/<tool>`.
>
> ```bash
> npx parse-gl init
> ```
>
> To install just the skills: `npx skills add Parsegl/skills`.
> Every tool is also a POST to https://agent.parse.gl/v1/tools/<tool>; its OpenAPI description is https://agent.parse.gl/openapi.json.

# Ask AI engines now, or baseline a brand

> ask_ai_engines: a workspace tool on Parse for agents (agent.parse.gl). Arguments, price, and a call over REST and MCP.

Ask AI engines or search APIs live now, or run a brand baseline (paid: \$0.01/check standard, \$0.05/check on Gemini and Claude, runs within monthly budget; quote: true prices without buying). Choose surfaces by id or preset (default, answers, all\_answers, memory, all\_memory, search, all), places, language, and runs. Reuses recent ≤7d answers free unless fresh: true. Pass baseline (brd\_ id or domain) instead of questions to draft \~20 buyer questions and measure a brand (first run for workspace's own Free brand is free; again: true re-runs paid). Up to 1,000 questions × places; identical calls within the UTC hour deduplicate. Read job\_ id with read\_item.

## Who may call it, and what it costs

| Name | Access | Effect |
| - | - | - |
| `ask_ai_engines` | A workspace key, or a sign-in that allows changes. | Spends credits, within the budget |

**Price.** \$0.01 a check, on ChatGPT, Google AI Mode or any other AI engine. A check is one question asked once on one AI engine or search surface from one place. Answers Parse already holds from the last 7 days that the workspace may read fill the runs they can, free; `fresh: true` buys every run. A baseline (`baseline`) is about 20 questions × 2 engines = 40 checks, \$0.40; recent answers are reused and not charged, and the first run of the workspace's own Free brand is free. Runs when called, within the budget; `quote: true` prices it only and starts nothing. Every reply says what the call cost in `meta.costCredits`. The prices are on [Spending, tracking and stopping](/docs/credits.md).

## Arguments

**questions** `list of string`

the exact words to ask, up to 1,000 (questions × places up to 1,000) (or baseline instead) up to 1000

**baseline** `string`

the brand to measure: a brd\_ id, or its site's domain (a site Parse has never seen is read first)

**engines** `list of one of default, answers, all_answers, memory, all_memory, search, all, chatgpt_search, google_ai_mode, perplexity, gemini, claude, chatgpt_memory, claude_memory, gemini_memory, parallel, youcom, tavily, exa, linkup`

surface ids, and at most one preset: default (the counted engines and one search API), answers (1¢ answer engines: ChatGPT, Google AI Mode, Perplexity), all\_answers (every answer engine, including 5¢ Gemini and Claude), memory (1¢ search-off model), all\_memory (every search-off model, including 5¢ Gemini and Claude), search (every retrieval API whose rows may be returned), all (every surface but those withheld). exa, linkup return lists whose rows Parse may not pass on: no preset buys them, a call that names one does. Nothing given is default up to 20

**places** `list of string`

questions only: where to ask from, up to 50: plc\_ ids from resolve\_ids, country codes ("DE") or names, or place names ("Austin, Texas"); default the United States. An unknown or ambiguous place is refused, never asked from elsewhere. A surface that takes no place (a model with its search off, a search API) is asked once a question. Google AI Mode often returns nothing for a city-worded or US-default local ask (refunded, never charged); a country code answers up to 50

**placeMode** `one of named, near_me`

questions only: named (default): puts the place in the question so every engine answers for it; near\_me: asks bare wording from Google locationCode (Google AI Mode only)

**language** `string`

questions only: the answer language, e.g. "de"; default English

**runs** `integer`

questions only: answers per answer engine per question, up to 100; default 1. A search API returns one list a question whatever this says min 1, max 100

**fresh** `boolean`

questions only: true: buy every run. Left out, answers Parse already holds from the last 7 days that this workspace may read fill the runs they can, free, and only the rest are bought

**again** `boolean`

baseline only: measure a brand again whose free first run is finished: this is a paid run. A plain call on such a brand returns the first run at no charge

**quote** `boolean`

true: the price and whether it fits, buying nothing; without it the call runs when it fits

**confirm** `boolean`

baseline only: in a workspace with no brand yet, a call returns the price and the free claim first: true buys the run, for a brand that is not the person's own. Otherwise not needed: the call runs when it fits

**idempotencyKey** `string`

the same key with the same arguments returns the same job and charges nothing more; other arguments are refused. Left out, an identical call within the UTC hour is the same call; pass a key to buy it again

Every argument the tool takes, as `GET /v1/tools` serves it, every shared object written out; `https://agent.parse.gl/openapi.json` serves the same schema with the filter and the window named once under `components` and pointed to by `$ref`. MCP `tools/list` leaves out the arguments few calls send, and says the filter and the window once, under `search_answers`; `resolve_ids {"kinds": ["argument"]}` lists what it left out, and a call with any of them runs:

```json theme={null}
{
  "type": "object",
  "properties": {
    "questions": {
      "description": "the exact words to ask, up to 1,000 (questions × places up to 1,000) (or baseline instead)",
      "minItems": 1,
      "maxItems": 1000,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 5,
        "maxLength": 300
      }
    },
    "baseline": {
      "type": "string",
      "minLength": 3,
      "maxLength": 253,
      "description": "the brand to measure: a brd_ id, or its site's domain (a site Parse has never seen is read first)"
    },
    "engines": {
      "description": "surface ids, and at most one preset: default (the counted engines and one search API), answers (1¢ answer engines: ChatGPT, Google AI Mode, Perplexity), all_answers (every answer engine, including 5¢ Gemini and Claude), memory (1¢ search-off model), all_memory (every search-off model, including 5¢ Gemini and Claude), search (every retrieval API whose rows may be returned), all (every surface but those withheld). exa, linkup return lists whose rows Parse may not pass on: no preset buys them, a call that names one does. Nothing given is default",
      "minItems": 1,
      "maxItems": 20,
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "default",
          "answers",
          "all_answers",
          "memory",
          "all_memory",
          "search",
          "all",
          "chatgpt_search",
          "google_ai_mode",
          "perplexity",
          "gemini",
          "claude",
          "chatgpt_memory",
          "claude_memory",
          "gemini_memory",
          "parallel",
          "youcom",
          "tavily",
          "exa",
          "linkup"
        ]
      }
    },
    "places": {
      "description": "questions only: where to ask from, up to 50: plc_ ids from resolve_ids, country codes (\"DE\") or names, or place names (\"Austin, Texas\"); default the United States. An unknown or ambiguous place is refused, never asked from elsewhere. A surface that takes no place (a model with its search off, a search API) is asked once a question. Google AI Mode often returns nothing for a city-worded or US-default local ask (refunded, never charged); a country code answers",
      "maxItems": 50,
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 2,
        "maxLength": 80
      }
    },
    "placeMode": {
      "description": "questions only: named (default): puts the place in the question so every engine answers for it; near_me: asks bare wording from Google locationCode (Google AI Mode only)",
      "type": "string",
      "enum": [
        "named",
        "near_me"
      ]
    },
    "language": {
      "description": "questions only: the answer language, e.g. \"de\"; default English",
      "type": "string",
      "pattern": "^[a-z]{2}$"
    },
    "runs": {
      "description": "questions only: answers per answer engine per question, up to 100; default 1. A search API returns one list a question whatever this says",
      "type": "integer",
      "minimum": 1,
      "maximum": 100
    },
    "fresh": {
      "description": "questions only: true: buy every run. Left out, answers Parse already holds from the last 7 days that this workspace may read fill the runs they can, free, and only the rest are bought",
      "type": "boolean"
    },
    "again": {
      "description": "baseline only: measure a brand again whose free first run is finished: this is a paid run. A plain call on such a brand returns the first run at no charge",
      "type": "boolean"
    },
    "quote": {
      "description": "true: the price and whether it fits, buying nothing; without it the call runs when it fits",
      "type": "boolean"
    },
    "confirm": {
      "description": "baseline only: in a workspace with no brand yet, a call returns the price and the free claim first: true buys the run, for a brand that is not the person's own. Otherwise not needed: the call runs when it fits",
      "type": "boolean"
    },
    "idempotencyKey": {
      "description": "the same key with the same arguments returns the same job and charges nothing more; other arguments are refused. Left out, an identical call within the UTC hour is the same call; pass a key to buy it again",
      "type": "string",
      "maxLength": 100
    }
  },
  "additionalProperties": false
}
```

## Example call

Price a question asked now on the default surfaces, and buy nothing. Over REST:

```bash theme={null}
export PARSE_API_KEY="<your-key>"

curl -s -X POST https://agent.parse.gl/v1/tools/ask_ai_engines \
  -H 'content-type: application/json' \
  -H "Authorization: Bearer $PARSE_API_KEY" \
  -d '{"questions":["best project management tool for agencies"],"quote":true}'
```

Over MCP, the assistant calls the tool by name with the same arguments:

```json theme={null}
{
  "method": "tools/call",
  "params": {
    "name": "ask_ai_engines",
    "arguments": {
      "questions": [
        "best project management tool for agencies"
      ],
      "quote": true
    }
  }
}
```

More calls:

* Ask a question now with Austin written into it, so every engine answers for Austin; fresh answers Parse holds for the placed words are reused for \$0: `{"questions":["best plumber near me"],"places":["Austin, Texas"]}`
* Ask the bare words from the place's Google location code, as someone there would (Google AI Mode only): `{"questions":["best plumber near me"],"places":["<plc_ id from resolve_ids>"],"placeMode":"near_me"}`
* Buy five new answers an engine today, reusing none Parse already holds: `{"questions":["best project management tool for agencies"],"runs":5,"fresh":true}`
* Price a baseline for a brand, and buy nothing: `{"baseline":"acme.com","quote":true}`
* Measure a brand now: `{"baseline":"acme.com"}`

The reply has `data`, `context`, `next`, `page` and `meta`; follow `next` for the calls that come after. A refused call returns `{ code, message, fix }`: see the [error table](/docs/mcp-reference.md#errors).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.