# Quickstart
> Set up DeepSieve in your coding agent with one prompt
Connect DeepSieve and your agent gets a **cited, structured dataset it can
query, re-verified while monitoring is on** — instead of re-researching the same
subjects on every task.
Don't configure it by hand — let your coding agent do it. Paste this into
Claude Code, Cursor, Copilot, Codex, or any assistant that can read a URL:
```agent-prompt
Set up DeepSieve by following the instructions here:
https://deepsieve.ai/setup.md
```
**Your agent will then:**
1. Detect which agent it is and whether it can open a browser.
2. Connect the DeepSieve MCP server (`deepsieve`) — browser login, or an API
key if it's running headless.
3. Install the DeepSieve Agent Skill, and append a `## DeepSieve` section to your
agent's rules file (`CLAUDE.md`, `AGENTS.md`, or `.cursor/rules/`).
4. Offer to install the CLI if you work in a terminal.
5. Verify the connection and report your workspace, scopes, and run costs.
**What it will not do**, stated as constraints the payload itself carries:
- **Never start a research run.** Runs cost money — [$10 standard, $20 at max
depth](/developers/runs). Setup spends nothing, explicitly including "to
check it works".
- **Never ask you for an API key in chat** while browser login is available —
transcripts get logged and shared.
- **Never install a global runtime or touch your shell config**, and nothing
outside this project and your agent's own config.
Read it yourself before you run it — it's plain markdown, and the constraints
above are in its own words: **[https://deepsieve.ai/setup.md](https://deepsieve.ai/setup.md)**.
## Prefer to wire it yourself?
There's a full REST API underneath all of this — see **[The API](/developers/api)**
for the whole surface, one link per component. The options below are the common
starting points.
Connect the MCP server manually
The server is at `https://deepsieve.ai/mcp` and uses browser login — no API key.
```bash
claude mcp add --transport http deepsieve https://deepsieve.ai/mcp
```
Then run `/mcp`, pick `deepsieve`, and choose **Authenticate**.
For config-file agents (Cursor `.cursor/mcp.json`, VS Code `.vscode/mcp.json`),
register the same URL — full per-agent snippets are in
[MCP server](/developers/mcp).
Headless / CI (no browser)
Create a key at [Settings → API keys](/settings/api-keys) with the **Agent**
preset (runs research and reads results; can't change your schema or spend
settings). Put it in the environment as `DEEPSIEVE_API_KEY` — never in a commit
or a chat message.
```bash
claude mcp add deepsieve -- uvx deepsieve-mcp
```
Or call the REST API directly:
```bash
curl -s https://deepsieve.ai/v1/me -H "Authorization: Bearer $DEEPSIEVE_API_KEY"
```
```json-response
{"object": "identity", "org_id": "…", "role": "admin",
"workspace_schema": "…", "auth_kind": "api_key",
"scopes": ["data:read", "export:read", "runs:read", "runs:write", "…"]}
```
Work in a terminal? Use the CLI
```bash
uv tool install deepsieve-cli
deepsieve login
```
Browser sign-in, then `deepsieve runs create --query "..." --dry-run --wait`.
Full reference: [CLI](/developers/cli).
Just the skill (no MCP)
The skill teaches any assistant to drive the REST API — auth, running research,
reading cited data:
```bash
npx skills add https://deepsieve.ai
```
[Agent Skills](https://agentskills.io) is an open standard, so the same package
works in Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI and ~70 other
clients. Target one agent with `-a claude-code`, or install globally with `-g`.
No Node? It's plain markdown at stable URLs — fetch and drop into your agent's
skills directory, preserving the relative paths:
```bash
curl -s https://deepsieve.ai/.well-known/skills/index.json # name + every file
curl -sO https://deepsieve.ai/.well-known/skills/deepsieve/SKILL.md
```
## Two free paths, and they answer different questions
**Your first real research run is free** — one per account, before you subscribe.
It's a genuine run on your own question, and its report is readable (capped at
10 rows). If it fails, it isn't consumed. That's the one that tells you whether
the *research* is any good, because you get real cells about a market you know,
each with its sources and a `verdict` — including `contradicted` and
`unverifiable` when we couldn't stand a claim up. See
[reading a citation honestly](/developers/dataset-sync#reading-a-citation-honestly).
**`dry_run` is free and unlimited** — it tells you whether your *integration*
works. Same shape, same statuses, ~15 seconds, nothing billed or persisted, but
the rows are samples. Build your poll loop here; judge the product on the free
real run.
Every integration should be built against `dry_run` first. It behaves exactly
like a real run — `202` + `Location`, poll to completion — but finishes in ~15
seconds, costs nothing, and persists nothing:
```bash
curl -s -X POST https://deepsieve.ai/v1/research/runs \
-H "Authorization: Bearer $DEEPSIEVE_API_KEY" -H "Content-Type: application/json" \
-d '{"query": "anything", "dry_run": true}'
```
It returns sample **cited** rows in your Blueprint's real shape (`"test": true`).
Build your whole create → poll → parse loop here, then drop `dry_run`.
Ask your agent to do this for you — "start a dry run and show me the rows" —
once setup finishes.
## Where next
- **See the whole API** → [The API](/developers/api)
- **Run research from my app** → [Your first research run](/developers/first-run)
- **All the MCP tools** → [MCP server](/developers/mcp)
- **Work from a terminal** → [CLI](/developers/cli)
- **Which integration should I use?** → [Choosing an integration](/developers/integrations)
- **Sync results into my systems** → [Dataset sync](/developers/dataset-sync) + [Webhooks](/developers/webhooks)
- **Ask about a value, or get it re-checked** → [Chat with the research agent](/developers/chat)
Machine-readable: [/llms.txt](/llms.txt) · [/llms-full.txt](/llms-full.txt) ·
[/openapi.json](/openapi.json) — and any page here is markdown if you append `.md`.