ChatGPT Deep Research Alternatives (Bring Your Own Key)

ChatGPT’s deep research mode sits behind two walls: $20 a month for Plus with a task allowance that resets every 30 days, and $200 a month for Pro if you need more. Neither wall accepts an API key. If you want a ChatGPT deep research alternative that runs on your own tokens, your own machine, or a model you picked yourself, this page is the shortlist, and one of the five I actually ran this morning, for $0.0091.

Verdict first. If you want good reports and don’t care whose servers read the sources, ChatGPT Plus is still the sane default, and Perplexity or Gemini belong on the same shopping list. The bring-your-own-key shelf exists for three specific pains: the monthly caps, the model lock-in, and the fact that your research question leaves your machine. Pick Magpie if you want a hard cost cap and citations Go verified against the fetched pages. Pick GPT Researcher if you want a Python web app you can bend. Pick Local Deep Research if the tokens must cost zero. The rest of this page earns those picks.

Tool	Runs where	You pay	Search backends	The catch
ChatGPT Deep Research (baseline)	OpenAI’s cloud	Plus $20/mo, Pro $200/mo	OpenAI’s own	Closed: no keys, no model choice, plan-level caps
Magpie	Your machine, CLI + desktop app	Tokens only (one quick run cost me $0.0091)	DuckDuckGo keyless; keyed backends opt-in	No chat UI: one question in, one report out
GPT Researcher	Your machine, Python + web UI	Tokens + a Tavily key	Tavily by default, swappable	Python stack, two API keys to manage
Open Deep Research (LangChain)	Your machine, LangGraph server	Tokens + a Tavily key	Tavily, MCP servers, native web search	Config surface; you tune four model roles
dzhng/deep-research	Your machine, Node	Tokens + a Firecrawl key	Firecrawl	A script you fork, not a product
Local Deep Research	Your machine, Docker or pip	$0 tokens (Ollama, LM Studio, llama.cpp)	SearXNG + arXiv, PubMed, Wikipedia	Your GPU decides the quality

Ordering is by how much the tool decides for you. Each entry names the job it wins and the one it loses.

What ChatGPT Deep Research gets right

OpenAI launched deep research in February 2025, and the current version is good. You describe the outcome, it proposes a research plan you can edit before anything runs, then it browses with visible progress, takes source restrictions (specific sites only, or prioritized), and returns a structured report with citations you can export as Markdown, Word, or PDF. It reads connected apps like Google Drive and SharePoint, which none of the local tools do as smoothly. Per OpenAI’s FAQ, usage varies by plan and resets 30 days after your first use, tracked in a counter inside the product.

That feature set is the bar. Everything below is measured against it, and the honest notes cut both ways.

Why people look for a ChatGPT deep research alternative

Three frictions drive the search, and price is the least of them.

Caps first. Every plan has a task allowance, the counter is the only place you can see it, and a heavy research week means choosing which questions deserve a task. On Plus you feel it by mid-month; on Pro you pay $200 to stop feeling it.

Model lock-in second. Deep research runs OpenAI’s models, full stop. If you’ve priced a capable model on OpenRouter, run Ollama on a desk GPU, or have an Anthropic key from work, you can’t point any of that at ChatGPT. The hosted competitors don’t help: Perplexity, Gemini, and Claude each lock you to their own models too.

Data third. Your question, the sources it pulls, and the report all live in ChatGPT’s history under its retention and training settings. For market research on your own company, legal questions, or anything under NDA, that’s the dealbreaker, and it’s the reason every tool below exists at all.

If none of those bite, stay on ChatGPT. If one does, keep reading.

Five research agents that take your own keys

Magpie: cost-capped research with quote-checked citations

Magpie is a local scraper and research CLI (AGPL-3.0 or commercial; the desktop app is free for 5 runs, then $49/mo). Its research command plans a question, fetches pages, and writes a report where every footnote is a quote the Go binary checked against the page it stores, with a checked-at timestamp. The model cites fact IDs, not raw URLs, so a citation is a claim about stored text, not a link the model typed and hoped exists.

Here is the run I did this morning, quick effort, on a live question:

magpie research "Which open-source deep research agents support bring-your-own API keys or local models?" --provider openrouter --effort quick --yes

estimate: ~13 LLM calls, ≤ 10 tool calls, ≈ $0.00 (cap $1.00)
done    done ($0.0091 of $1.00)
run_id=a5a381530279c455-39085 status=done spent=$0.0091

(abridged; full output on stderr.) The report came back 502 words, built from 50 verified facts, with footnotes like this one, machine-checked against the stored page:

The mechanics that matter: effort is quick|standard|deep, which means 1, 3, or 5 sub-researchers; the global --max-cost defaults to $1.00 and stops the run at 85% of it so a report still gets written; search defaults to keyless DuckDuckGo so a report works with zero API keys beyond the model’s; and --allow-domain, --deny-domain, --prefer-domain, plus --from/--to date filters constrain where it reads. Ctrl-C before plan approval cancels; once mid-run, it writes the report from verified facts. Seven model providers are built in, including Ollama for local models, which makes this a zero-token deep research setup too (see web scraping with a local LLM for the same idea applied to extraction).

The honest limit, plainly: there is no chat UI. One question in, one report out. You cannot follow up mid-report, argue with it, or steer after approval the way ChatGPT’s interrupt-and-refocus lets you. You refine by editing the question and re-running, which costs tokens again. The desktop app’s Research screen gives you a compose box, a live log, and recent runs, but it is a form, not a conversation. If your workflow is “chat with my research,” Magpie is the wrong tool. If it is “produce a cited report under a cost cap,” it’s the right one, and it feeds the same store as the 13-tool MCP server if your agent does the asking.

GPT Researcher: the Python multi-agent

The oldest serious entry here is GPT Researcher (Apache-2.0, 30,131 stars on GitHub today), and its planner/execution architecture is what most newer agents copy: a planner generates research questions, execution agents crawl and summarize in parallel, a publisher writes the report. Reports routinely clear 2,000 words from 20-plus sources, and you get a web UI on localhost:8000, a pip package, PDF/Word export, and an MCP mode (RETRIEVER=tavily,mcp) for feeding it into your own agent stack.

Setup is two keys and a Python 3.12 environment:

export OPENAI_API_KEY=...   # or OPENAI_BASE_URL for a local endpoint
export TAVILY_API_KEY=...
pip install -r requirements.txt
python -m uvicorn main:app --reload

It wins on maturity and the size of the community around it; there is a documentation site, Docker images, and answers for most failure modes. It loses on key sprawl (an LLM key plus Tavily, Tavily’s free tier being about 1,000 searches a month) and on Python weight if your stack isn’t already Python. The model quality you feed it decides the report quality, same as every BYOK entry here. We have a full page on it at GPT Researcher alternatives; if you’re comparing agents rather than subscriptions, start there.

Open Deep Research: the benchmark runner

LangChain’s Open Deep Research (MIT, 12,682 stars) is the one with published receipts. It ranked #6 on the Deep Research Bench leaderboard (a RACE score of 0.4344 at submission), and its README tables show what raw-API research really costs: $45.98 for the full 100-task benchmark on the default model config, $187.09 with Claude Sonnet 4 doing the research leg. That’s the most honest cost data in the open-source field, and it doubles as a warning: agent quality tracks token spend.

It runs as a LangGraph server with the Studio UI, supports any provider through LangChain’s init_chat_model interface, splits the work across four model roles (summarizer, researcher, compressor, final writer), and speaks MCP natively. Searxng-style tinkerers get search via Tavily by default with full MCP compatibility. It wins on configurability and verifiable quality. It loses on ceremony: a uv environment, a LangGraph server, and four model roles to configure before the first report. If you want to study how deep research agents work or benchmark a new model yourself, this is the repo; if you want reports today, it’s the longest setup here.

dzhng/deep-research: a loop you fork

dzhng/deep-research (MIT, 19,791 stars) is the minimal one: a TypeScript loop that generates queries, searches via a Firecrawl API key, evaluates what it learned, and recurses until your breadth/depth settings say stop, then writes the report. It runs from the console or Docker, and local models connect through an OpenAI-compatible endpoint (OPENAI_ENDPOINT plus OPENAI_MODEL, per its README).

This is the entry for embedding research inside your own app; the whole thing is a few files you can read in an afternoon. It’s also the entry that will make you maintain a research agent, handle concurrency limits, and wire your own export, because there’s no UI worth speaking of. Fork it to ship a feature. Don’t fork it to answer questions on Tuesday.

Local Deep Research: zero tokens, your GPU

Zero tokens changes the tool, not just the bill. Local Deep Research (MIT, 9,243 stars) is the fully-local answer: Ollama, LM Studio, or llama.cpp for the model, SearXNG for search, plus free academic engines (arXiv, PubMed, Semantic Scholar, Wikipedia) behind a web UI on localhost:5000. The README’s benchmark claim is the strongest local number I’ve seen published: about 95% on SimpleQA (n=500), fully local on a single RTX 3090 with Qwen3.6-27B, via its langgraph-agent strategy.

pip install local-deep-research
python -m local_deep_research.web.app   # http://localhost:5000

The catch is the one every local stack shares: a 27B model needs the VRAM to match, and a laptop GPU will trade report quality for the privilege. For a researcher with a desktop card and an NDA, it’s the whole package. For an ultrabook, it isn’t.

The hosted shelf, briefly

Most people searching this keyword actually want these, so here they are without contempt. Perplexity’s Deep Research is the fastest of the three and its Pro tier is $20/mo; free accounts get a small daily allowance. Gemini’s Deep Research ships with Google AI Pro ($19.99/mo), pulls Google Workspace sources, and free access exists with a cap Google doesn’t publish. Claude’s research feature (Pro from $20/mo, Max from $100/mo) writes the most readable reports of the hosted field and leans on Claude’s web search and integrations.

All three share ChatGPT’s trade: their models, their caps, your data on their servers. If that trade is fine, the hosted path is less work than anything on the BYOK shelf, and there’s no shame in it.

What deep research actually costs on your own keys

The numbers, so you can stop guessing. My quick Magpie run: $0.0091. A monthly Plus subscription at $20 buys about 2,200 runs at that quality tier, which is the honest way to say BYOK is cheaper per run but buys you no hand-holding. At the top tier, Open Deep Research’s own published benchmark runs put a full-fat research task at roughly $0.46 on default models and $1.87 with Claude Sonnet 4 (their totals: $45.98 and $187.09 for 100 tasks). Deep effort on Magpie scales the same direction, five sub-researchers reading more pages, and the --max-cost cap decides the ceiling before the first token.

Two rules fall out of the arithmetic. One: quick effort is for orientation, standard for real questions, deep for decisions; a cheap run buys a cheap report, and my quick run found listicle-grade sources that a deeper pass would have traded up. Two: if your question volume is under a few dozen serious reports a month, the subscription’s convenience still beats the meter. Past that, or with local models, BYOK wins outright. The per-model prices behind that math live in our LLM scraping cost breakdown.

FAQ

Is there a free alternative to ChatGPT Deep Research? Local Deep Research runs entirely on your hardware with Ollama and SearXNG: no token bill, no subscription. Magpie with --provider ollama is the same idea with a cost-capped pipeline. On the hosted side, Perplexity gives free accounts a small daily deep research allowance.

Can I use my own API key with ChatGPT itself? No. Deep research is part of Plus, Pro, Team, and Enterprise subscriptions and runs OpenAI’s models only. There is no key slot. BYOK means moving to a different frontend like the ones above.

How much does deep research cost with your own API key? Pennies at quick effort (my run: $0.0091) and roughly $0.46 to $1.87 per serious task at full effort, based on Open Deep Research’s published benchmark totals. Cap it in software: Magpie defaults to a $1.00 ceiling per run.

Which deep research tool works with Ollama? Magpie takes --provider ollama directly. Local Deep Research is built around Ollama (or LM Studio, or llama.cpp). GPT Researcher and dzhng/deep-research reach local models through OpenAI-compatible base URLs. Open Deep Research connects Ollama through LangChain’s init_chat_model.

Is Magpie’s research mode the same as ChatGPT Deep Research? No, and the difference is structural. Both show an editable plan first and produce cited reports. ChatGPT gives you a chat you can interrupt and steer; Magpie gives you a pipeline: one question, a cost cap, and footnotes whose quotes the binary re-checked against stored pages. No follow-up conversation.

The pick, by job

Cited reports under a spend ceiling, from a terminal or a desktop app: install Magpie, set one model key, run the command above at --effort standard. A Python web app your team can extend, with the largest community behind it: GPT Researcher. Research where the data never touches a cloud: Local Deep Research on a machine with a real GPU. And if none of those constraints apply, cancel nothing, keep the $20, and let ChatGPT do the driving.