> ## Documentation Index > Fetch the complete documentation index at: https://docs.parsaa.app/llms.txt > Use this file to discover all available pages before exploring further. # MCP & Agents > Point Claude Code, Cursor or Codex at an Orbit project Orbit exposes a project's data and a few actions over the **Model Context Protocol**, so an agent in your editor can read the reviews, crashes, sessions, screens and memory it needs instead of being told about them. ## The endpoint | | | | ---------- | ----------------------------------------------------- | | URL | `https://platform.parsaa.app/api/orbit/mcp` | | Transport | Streamable HTTP, `POST` only | | Auth | `Authorization: Bearer ` | | Rate limit | 1,200 requests a minute; one tool call is one request | It is the same origin as the console, so there is one host to trust and no CORS. Sessions are stateless: no session id is issued or required, and a revoked token stops working on the very next call. `GET` answers 405 on purpose, because the server raises no notifications of its own and the live tail stays on the console. JSON-RPC batches are refused, so a batch cannot buy N calls for the price of one. Everything about it is described in the console under **Settings**, then **Project**, then **MCP** (`/settings/project/mcp`), which any member can read. Only minting the token an agent connects with is admin or owner. ## Two credentials | | Project token (`orbit auth`) | Sign-in session (`orbit login`) | | ----------------- | --------------------------------------------------------------------------------------- | --------------------------------- | | Belongs to | A machine | You | | Reaches | Exactly one project | Every project you are a member of | | Names the project | Implicitly | `project_id` on every tool call | | Paid tools | Never. They answer `needs_user` with a console link, because there is no person to bill | Yes, debiting your credits | | Expires | No, it is revoked | Yes, and is renewed automatically | CI wants the first. An editor on your own laptop usually wants the second. ## Connecting an editor ```bash theme={null} claude mcp add orbit --transport http \ https://platform.parsaa.app/api/orbit/mcp \ --header "Authorization: Bearer orbit_..." ``` Or sign in as yourself and drop the header entirely, see below. In `mcpServers`: ```json theme={null} { "mcpServers": { "orbit": { "url": "https://platform.parsaa.app/api/orbit/mcp", "headers": { "Authorization": "Bearer orbit_..." } } } } ``` In `~/.codex/config.toml`: ```toml theme={null} [mcp_servers.orbit] url = "https://platform.parsaa.app/api/orbit/mcp" bearer_token_env_var = "ORBIT_TOKEN" ``` Codex is the odd one out on purpose: it points at an environment variable rather than writing a secret into a file that tends to get committed. The console prints all three configurations with your real token in them at the one render where the secret exists, on **Settings**, then **Tokens**, right after you create it. The reference copies with a placeholder live on **Settings**, then **MCP**. **Test connection** on the MCP settings page runs `initialize` and then `tools/list` the way an editor runs them, and answers with the server it reached and how many tools that credential is offered, grouped into read, free actions and paid. Paste a project token to see exactly what an agent holding it gets, or leave the field empty to test as yourself. It reads nothing from the project and changes nothing, and the token is never stored. ## Signing in from the editor You do not have to paste a secret anywhere. Claude Code, Cursor and Codex discover the authorization server from Orbit's own metadata and run a device flow, and `orbit login` does the same thing from the terminal: ```bash theme={null} orbit login ``` It prints an eight character code **before** opening the approval page, so you can compare what the CLI asked for with what the page shows you. Approve it at `/account/devices/approve` in the console, reachable from **Settings**, then **Account**, then **Security** as "Approve a device". The session then reaches every project you are a member of and can run the paid tools against your own credits. What the grant carries is decided by the API from the code it stored, not by the link you clicked, so an edited URL can only fail to describe the request. It can never widen it. ## The tool groups Tools are grouped by what they cost, and a token's **scopes** decide which ones it is offered. Scopes are ticked on the create form under Settings, Tokens, and they govern MCP and nothing else: the REST API and the `orbit` CLI ignore them entirely. ### Read, scope `read`, free Project overview, reviews and one review, learnings, agent runs, verify status, the screen map and one screen, crash groups, telemetry sessions and one session's timeline, users, issues, vitals, the fleet, Instruments recordings, test runs and cases, builds, release and compliance, memory search and get, the compiled instructions, nine analytics tools, and a full text `orbit_search` across findings, crash groups, issues, screens and test cases. ### Free actions, scope `write` Set a finding's state with a reason, send a finding to the agent, apply a finding's suggestion, add a review rule, request a visual diff, ask for a screen re-capture, write and update memory, link memories, and leave feedback on one. A token without `write` is simply not shown these. ### Paid, user session only `orbit_request_review`, `orbit_analyze_crash`, `orbit_analyze_trace` and `orbit_analytics_ask`. Each returns an **estimate** in its first call and runs only with `confirm: true`, so nothing is spent without a price being quoted. A project token gets `needs_user` with a link into the console rather than a failure. ## Resources and prompts A **resource** is the same data addressed by URI instead of fetched by a call, so a client attaches one and keeps it in view. | URI | What it is | | -------------------------------------------- | -------------------------------------------------------- | | `orbit://project/{projectId}/{surface}/{id}` | One record: a review, a crash group, a session, a screen | | `orbit://memory/instructions` | The compiled instruction bundle | | `orbit://memory/{slug}` | One memory | | `orbit://docs/{page}` | The console guide for a surface | A **prompt** is a starting instruction a person picks in their editor. The server writes it; it does not run it. Two of the seven matter most: **`recall_before_task`** reads the project's instructions and searches memory with the task's own words before anything is proposed, and **`remember_after_task`** writes at most three memories afterwards. That pair is what makes the rest worth having. ## Memory instructions Every memory marked as an instruction, compiled into one document. An agent reads it with the `memory_instructions` tool or attaches `orbit://memory/instructions`, and it is the same text `orbit memory pull` writes to `AGENTS.md` and `CLAUDE.md`, so the editor and the repository never disagree. Anything an agent writes back arrives in the console like any other memory: marked as agent-authored with the token's name and the tool that made it, held to a confidence of at most 0.7, and listed under Curation for a person to activate, edit or archive. A project can require approval for agent writes, which turns those into drafts instead. The tools refuse a write carrying something secret-shaped. ## What a tool can never do A tool does not run a query of its own. Each one names an OpenAPI path and method, and the API dispatches to it in process with **your** credential, so the call walks the same router and the same access checks a REST request would. There is no second access-control path. A tool never returns secrets, SDK keys, token hashes, long-lived signed URLs, or another project's data, and nothing over 64 KB comes back in one response. `orbit mcp` for editors that speak only stdio, plus uploads and memory. Connecting MCP servers to Parsaa itself.