> ## 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.

# Get started

> Add Parse to Claude, ChatGPT, Claude Code, Cursor, Codex, OpenCode or a script: where to paste the address, what the sign-in asks, and how to tell it worked.

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 theme={null}
npx parse-gl init
```

To install just the skills: `npx skills add Parsegl/skills`.

## 1. Add Parse to the assistant

Every snippet names the server `parse-agent`, so it sits beside an older `parse` entry instead of clashing with it. The address is the same everywhere:

```text theme={null}
https://agent.parse.gl/mcp
```

| Assistant | How | Signs in with |
| - | - | - |
| Claude | Settings › Connectors › Add custom connector, then paste the address | Parse, when it asks |
| ChatGPT | Settings › Apps & Connectors › Create, then paste the address | Parse, when it asks |
| Claude Code | A command, below | Parse, or a key |
| Cursor | A one-click link, or a file, below | Parse, or a key |
| Codex | One command, or a config file below | Parse, or a key |
| OpenCode | A command, below | Parse, when it asks |
| A script, CI or any client that cannot sign in | REST, below | A key, or nothing for the public tools |

The paths are the menus as last seen; an assistant's menus move between versions. Where a menu differs, look for custom connectors or MCP servers and paste the address.

> [tab] Claude
>
> * Open Settings › Connectors › Add custom connector.
> * Name it Parse and paste `https://agent.parse.gl/mcp`.
> * Add it. Claude opens Parse's sign-in the first time it uses the connector: continue with step 2.
>
> A connector sends no key. **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] ChatGPT
>
> * Open Settings › Apps & Connectors › Create.
> * Name it Parse and paste `https://agent.parse.gl/mcp`.
> * Create it. ChatGPT opens Parse's sign-in the first time it uses the connector: continue with step 2.
>
> A connector sends no key. **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] Claude Code
>
> With no key, so the assistant signs in:
>
> ```bash theme={null}
> claude mcp add --transport http parse-agent https://agent.parse.gl/mcp
> ```
>
> The first time Claude Code uses the server, it opens Parse's sign-in: continue with step 2. With a workspace key from [Agents](https://parse.gl/app/settings/agents), set the key in the same shell, and the command stores what it reads:
>
> ```bash theme={null}
> export PARSE_API_KEY="<your-key>"
> claude mcp add --transport http parse-agent https://agent.parse.gl/mcp \
>   --header "Authorization: Bearer $PARSE_API_KEY"
> ```
>
> Assistants that show a server's prompts list Parse's one command, `start`. In Claude Code, type `/mcp__parse-agent__start` and then what you want done, in your own words: Parse adds one line asking the assistant to use your workspace and keep track of what changes.
>
> The Parse plugin (the folder `plugins/parse-agent`) carries the same address with no key and the `parse`, `parse-content`, and `parse-outreach` skills, which tell the assistant when and how to use the tools. Load it with `claude --plugin-dir "<path>/plugins/parse-agent"`. All three skills are published at [/.well-known/agent-skills/index.json](https://parse.gl/.well-known/agent-skills/index.json). To take Parse out again: `claude mcp remove parse-agent`.
>
> > [!TIP]
> >
> > **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] Cursor
>
> One click from a browser. This link adds the server with no key; Cursor then opens Parse's sign-in:
>
> ```text theme={null}
> cursor://anysphere.cursor-deeplink/mcp/install?name=parse-agent&config=eyJ1cmwiOiJodHRwczovL2FnZW50LnBhcnNlLmdsL21jcCJ9
> ```
>
> Or put it in `.cursor/mcp.json`:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "parse-agent": {
>       "url": "https://agent.parse.gl/mcp"
>     }
>   }
> }
> ```
>
> With a workspace key, the same file with the header, the placeholder replaced by the key itself:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "parse-agent": {
>       "url": "https://agent.parse.gl/mcp",
>       "headers": {
>         "Authorization": "Bearer <your-key>"
>       }
>     }
>   }
> }
> ```
>
> > [!TIP]
> >
> > **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] Codex
>
> Codex connects with a workspace key. Set it in the shell or profile that starts Codex, and add this to `~/.codex/config.toml`; Codex reads `PARSE_API_KEY` each time it starts:
>
> ```bash theme={null}
> export PARSE_API_KEY="<your-key>"
> ```
>
> ```toml theme={null}
> [mcp_servers.parse-agent]
> url = "https://agent.parse.gl/mcp"
> bearer_token_env_var = "PARSE_API_KEY"
> ```
>
> Install the three skills with `npx skills add Parsegl/skills`.
>
> > [!TIP]
> >
> > **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] OpenCode
>
> OpenCode adds Parse to the project's `opencode.jsonc` with its own command. It sends no key: a remote server signs in with Parse by default, from `/mcps` in OpenCode or with `opencode mcp auth`.
>
> ```bash theme={null}
> opencode mcp add parse-agent --url https://agent.parse.gl/mcp
> ```
>
> > [!TIP]
> >
> > **It worked** when the assistant's first Parse call returns a reply with `data` and `meta.costCredits`. Ask it: "Call get\_account", or "What changed for my brands?"

> [tab] Scripts, CI and the CLI
>
> Any tool is one POST: the tool's input as JSON, at `https://agent.parse.gl/v1/tools/<tool>`. The public view's tools answer with no key:
>
> ```bash theme={null}
> curl -s -X POST https://agent.parse.gl/v1/tools/check_brand \
>   -H 'content-type: application/json' \
>   -d '{"subject":"notion.so"}'
> ```
>
> With a workspace key, send it as the bearer token, and every tool answers:
>
> ```bash theme={null}
> export PARSE_API_KEY="<your-key>"
> curl -s -X POST https://agent.parse.gl/v1/tools/get_brief \
>   -H 'content-type: application/json' \
>   -H "Authorization: Bearer $PARSE_API_KEY" \
>   -d '{}'
> ```
>
> > [!TIP]
> >
> > **It worked** when the reply has `data` and `meta.costCredits`. A mistyped or revoked key is refused with `unauthorized`, not read as no key. The CLI, the envelope and paging are on the [MCP reference](/docs/mcp-reference.md#rest).

## 2. Sign in and allow access (a person)

When the assistant first uses Parse, it opens Parse's sign-in in the browser.

* **Sign in, or sign up.** Use the account that belongs to the workspace. Signing up here makes the workspace, with \$5 of credit for the paid tools. A workspace gets it when it is made, or when a person first connects an assistant to it, once per person and email address; it comes with the workspace, not with a key.
* **Pick the workspace,** if you belong to more than one. The assistant reaches only that workspace, with your role in it.
* **Read the access it asks for.** Reading (`parse:dashboard:read`) lets the assistant read the workspace's data. Allowing changes (`parse:dashboard:write`) also lets it act and spend: track a brand, ask AI engines now, fetch pages, track questions and save settings, all within the limits a person set.
* **Allow it.** The assistant goes back to work.

| Needs | Tools |
| - | - |
| Read access | [`check_brand`](/docs/mcp/tools/check_brand), [`resolve_ids`](/docs/mcp/tools/resolve_ids), [`query_metrics`](/docs/mcp/tools/query_metrics), [`search_answers`](/docs/mcp/tools/search_answers), [`search_cited_pages`](/docs/mcp/tools/search_cited_pages), [`read_item`](/docs/mcp/tools/read_item), [`get_brief`](/docs/mcp/tools/get_brief), [`list_work`](/docs/mcp/tools/list_work), [`get_account`](/docs/mcp/tools/get_account) |
| Changes allowed | [`export`](/docs/mcp/tools/export), [`ask_ai_engines`](/docs/mcp/tools/ask_ai_engines), [`fetch_live_pages`](/docs/mcp/tools/fetch_live_pages), [`classify_items`](/docs/mcp/tools/classify_items), [`track`](/docs/mcp/tools/track), [`log_work`](/docs/mcp/tools/log_work), [`update_settings`](/docs/mcp/tools/update_settings). A key made by a workspace admin reaches all of them. |

A call that needs more than the sign-in allows answers `unauthorized`. Reconnect Parse in the assistant's connector settings and allow changes.

If Parse's sign-in form shows although you are signed in to Parse in this browser, sign in again there: the assistant then continues. This is a known fault.

## 3. The first call: get\_brief (the assistant)

Call `get_brief` at the start of each session. It returns what changed since the last brief, each item with ready-to-run calls in `next`. Then turn names, domains and URLs into ids with `resolve_ids` and follow `next`. [Your first session](/docs/first-session.md) shows five things to ask.

> [!TIP]
>
> **It worked** when the reply has `data` and `meta.costCredits`. To check the connection alone, ask the assistant to call `get_account`, which returns the workspace's credits and keys.

## Or start in the browser (a person)

A person with no assistant yet starts at parse.gl with the brand's website, or from this link with it in:

```text theme={null}
https://parse.gl/check?q=acme.com
```

They see the brand's first results, then sign up to track it. No card required. It is the same workspace an assistant's sign-in makes, with the same \$5 of credit, so Parse can be added to an assistant later.

> [!TIP]
>
> **It worked** when the brand appears in their workspace.

## Make a key (a workspace admin)

On [Agents](https://parse.gl/app/settings/agents), a workspace admin creates a workspace key (`parse_mcp_…`). It shows once; Agents also shows each assistant's snippet with the key in it. A key is for scripts, CI, Codex and any client that cannot sign in; an assistant that can sign in with Parse does so with no key. Never ask the person to paste a key into chat.

A key reaches its own workspace with every tool. Revoking it on Agents stops it within a minute, and every call is logged with the key that made it.

## Try it without signing in

Add `https://agent.parse.gl/mcp` and skip the sign-in: the assistant reads Parse's public view, the same numbers parse.gl's public pages show. Ask it how often AI mentions a brand and who it picks instead: it answers from Parse and cites the brand's parse.gl page. Scripts get the same tools over REST at `https://agent.parse.gl/v1/tools`.

Logged out, replies are samples of up to 5 rows over the public window, with no paging, contacts or workspace; a trend or a list reaches back no further than the last 90 days. Your own brand in full, its first check and the weekly one, the brief and the work record need a free sign-in: ask the assistant for your brief (`get_brief`) and it asks you to sign in. The budgets are on [Rates and limits](/docs/limits.md#logged-out).

An agent with no account can start a workspace: POST [https://agent.parse.gl/v1/workspaces](https://agent.parse.gl/v1/workspaces) returns a key (sent as Authorization: Bearer parse\_uws\_…). Keep it secret and print it in no log: whoever holds it can start the claim. An unclaimed workspace reads Parse's public view, keeps the log\_work calls it is sent (list\_work returns them) and buys nothing; kept calls are filed into the work record when a person claims it. With no call for 14 days it is deleted. To claim, the agent asks the person for the email address they use at Parse, then sends POST [https://agent.parse.gl/v1/workspaces/claim](https://agent.parse.gl/v1/workspaces/claim) with the key and \{"email": "\<address>"}. The reply is the claim link, a 24-hour code and a new workspace key (parse\_mcp\_…) to store as a secret: it works from the person's claim. The person opens the link, signs in or signs up with that address and types the code there; the code goes into the page, never back to the agent. The agent keeps its current key until it is refused, then switches to the new one. Parse sends no email. A person claims it on Parse's claim page, signed in or signed up free with the address the agent named, by typing the code the agent showed them. The workspace key the claim start returned then works in their workspace with the access they choose, and the parse\_uws\_ key stops. Their workspace starts with \$5 of credit (once per person), runs their brand's first check (its 20 buyer questions on ChatGPT and Google AI Mode) and then checks it free every week on a panel of 8 questions. Every way in, as facts: [How an agent gets into Parse](https://parse.gl/auth.md).

## Credits for asks, baselines and tracking (a person)

Standard checks, live pages, judgments and rows outside your own data past the free ones cost \$0.01; frontier checks on Gemini and Claude cost \$0.05. Reading the last 90 days of what Parse already has is free: searches, numbers, excerpts, your own answers and pages in full, and 25 full texts of public answers or pages a day, then \$0.005 each. A public answer older than 90 days costs \$0.001 the first time your workspace counts or lists it, and is yours after. Each reply shows its cost in `meta.costCredits`. Asks, baselines, live fetches, rubrics and tracking run when the assistant calls them, within the workspace's monthly budget; past it nothing is bought and the reply is the quote. Only a person adds credits or raises the budget. Every price, and what each limit does, is on [Spending, tracking and stopping](/docs/credits.md).

## What Parse needs from the person

* The brand's website. Parse works out its markets and rivals from AI answers; the person corrects a rival or an answer about another company with the same name.
* A sign-in that allows changes, or a key, and credits for the paid tools. The person sets the monthly budget an assistant may spend without asking.
* Their own mail or the page's form to send a message. Parse never sends for them.


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