TL;DR
- Connect to the hosted Context.dev MCP server at
https://mcp.context.dev/mcpusing Streamable HTTP and browser-based OAuth. - In Cursor, add the URL to
mcp.json. In Claude, connect through the connector directory or add a custom remote connector. In Claude Code, useclaude mcp add --transport http. - Use
web-searchto discover sources,web-scrapeto read a page,web-crawlto read linked pages, andweb-scrapewithformats.jsonfor data shaped by a JSON Schema. - The hosted connection requires no Context.dev npm package, local scraping process, or API key pasted into your client configuration.
We checked this guide against the authenticated production server on September 21, 2026, and ran the search and Answers requests shown below against the live endpoint. We updated the tool names on September 30, 2026, after the server consolidated its per-format scraping tools into web-scrape. The server now exposes 40 tools.
What Context.dev MCP does for Cursor and Claude
Context.dev gives your AI client tools for retrieving current web and company data. The client discovers the tools and their input schemas, the agent selects an operation, and the hosted server executes it through Context.dev.
Context.dev manages page retrieval, JavaScript rendering, and scraping infrastructure. Your agent receives readable Markdown, page metadata, or structured data it can use in a research answer or development task. You can inspect the tool call and its source URLs in the conversation.
The live server exposes separate operations for different jobs:
| Task | MCP tool | What to request |
|---|---|---|
| Find relevant websites | web-search | A query, optional domain filters, and a result count |
| Read a known page | web-scrape | A URL, the formats to return, and content-selection options |
| Inspect page markup | web-scrape | A URL with formats.html when HTML structure matters |
| Discover a site's URLs | web-map | A domain and optional URL filters |
| Read several linked pages | web-crawl | A starting URL with page, depth, and time limits |
| Extract specific fields | web-scrape | A URL with formats.json, a JSON Schema, and extraction instructions |
| Research a question into JSON | web-answers | A research task and optional output format |
| Retrieve company branding | get-brand or brand-retrieve-unified | A domain for a visual profile, or a supported identifier for raw data |
| Parse a document | parse-document | File bytes encoded as Base64 |
| Process a large URL collection | submit-batch | An asynchronous scraping or crawling job |
The server also includes tools for recurring monitors, batch results, company news, design information, and account request logs. Choose the smallest operation that answers the question: reading one known page usually starts with web-scrape.
Before you connect
You need a Context.dev account, enough available credits for the operations you want to run, and a current MCP-capable client. In a managed workspace, your administrator may need to allow the connector.
The official MCP setup guide uses OAuth. Your client opens a browser, you sign in to Context.dev and authorize access, and the client manages the resulting connection. Keep the full server URL, including /mcp.
Set up Context.dev MCP in Cursor
Add the following entry to .cursor/mcp.json for one project, or ~/.cursor/mcp.json for all your projects. Preserve any other servers already inside mcpServers.
{
"mcpServers": {
"context": {
"url": "https://mcp.context.dev/mcp"
}
}
}Open Cursor's MCP controls in Customize, enable context, and complete the authentication prompt. If the configuration has not appeared, refresh the client or restart Cursor. Confirm that Context.dev tools are available before testing a prompt.
Cursor supports remote Streamable HTTP servers and OAuth. Its MCP documentation covers configuration locations, tool controls, and organization policies.
You can also use the official Context.dev Cursor plugin, which packages the MCP connection with guidance for using Context.dev. Choose one installation path to avoid registering the same server twice.
Set up Context.dev in Claude
Claude on the web and Claude Desktop
Open the Context.dev connector listing, select Connect, and complete the Context.dev sign-in and authorization flow. Enable Context.dev in the conversation's connector controls before asking it to fetch data. The Context.dev Claude guide walks through this connection.
For a manual setup, open Customize → Connectors, select + → Add custom connector, and enter:
- Name: Context.dev
- URL:
https://mcp.context.dev/mcp
Complete OAuth when prompted. This remote-connector flow works in Claude's web and desktop apps; organization policies can affect availability. See Claude's connector instructions for current controls.
Claude Code
Run this command to make the server available across your projects:
claude mcp add \
--transport http \
--scope user \
context \
https://mcp.context.dev/mcpStart Claude Code, run /mcp, select context, and authenticate in the browser. You can inspect configured servers from your terminal with:
claude mcp listFor a shared project configuration, use --scope project instead of --scope user. Claude Code writes the remote server entry to .mcp.json:
{
"mcpServers": {
"context": {
"type": "http",
"url": "https://mcp.context.dev/mcp"
}
}
}Keep "type": "http" in the Claude Code configuration. Each teammate authenticates their own connection. Claude Code's MCP documentation explains scopes and authentication.
Verify the connection with one page
Start a new conversation and ask:
Use Context.dev's web-scrape tool to read https://example.com as Markdown.
Return the page title and source URL, and tell me which tool you called.
Use the connected tool rather than answering from memory.Inspect the tool invocation. Some clients add a server prefix to the displayed name; the underlying Context.dev tool is web-scrape.
The following JSON is the params object for an MCP tools/call request. The examples throughout this guide use this same format. Your MCP client handles the protocol connection and authentication.
{
"name": "web-scrape",
"arguments": {
"url": "https://example.com",
"formats": { "markdown": true },
"sharedParams": { "mainContentOnly": true },
"markdownParams": { "includeLinks": true }
}
}A successful call returns markdown.success: true with the page in markdown.data, the title Example Domain in metadata.title, and a final url of https://example.com/. The response also includes cache_metadata and a request_id.
A written answer alone does not verify the connection. Confirm that the client invoked the Context.dev tool and received a successful result. If the agent uses another provider or answers from memory, check whether Context.dev is enabled and whether a tool approval is pending.
Search the live web
Once a page read works, try a discovery task:
Use Context.dev to find three recent official Node.js release posts.
Search nodejs.org, then read the selected pages to verify their publication
dates. Return each title, date, source URL, and a one-sentence summary.
If you cannot verify a date, say so.This request uses the actual web-search schema:
{
"name": "web-search",
"arguments": {
"query": "site:nodejs.org/en/blog/ Node.js releases",
"numResults": 10,
"includeDomains": ["nodejs.org"],
"freshness": "last_month"
}
}numResults accepts values from 10 to 100. Ask the agent to present three verified results after searching; the tool's input does not have a limit: 3 parameter. A restricted query may return fewer results than requested.
Our live call returned Node.js release pages with url, title, description, and relevance fields. Search results were not guaranteed to contain publication dates or full page text. Read the selected URLs with web-scrape before making claims about dates or article contents.
You can request inline page scraping through markdownOptions.enabled: true. Without it, our result entries contained markdown.code: "NOT_REQUESTED". Enabling that option adds page retrieval to the search workflow; use it when you need the content of the returned results.
The freshness filter narrows discovery. It does not establish that the first three ranked links are the three newest posts on the site.
Read JavaScript-rendered pages
Context.dev's web-scrape tool supports browser waits and content filters. This example reads a public JavaScript demo page and forces a fresh scrape:
{
"name": "web-scrape",
"arguments": {
"url": "https://quotes.toscrape.com/js/",
"formats": { "markdown": true },
"sharedParams": { "mainContentOnly": true, "waitFor": 2000 },
"markdownParams": { "includeLinks": true },
"timeoutOpts": { "milliseconds": 60000 },
"maxAgeMs": 0
}
}The response should contain the page's quote text in markdown.data, the title Quotes to Scrape in metadata.title, and a cache_metadata.status of miss. You can replace this URL with the public product, pricing, or documentation page you want to inspect.
These controls have distinct meanings:
sharedParams.waitForwaits a fixed number of milliseconds, up to 30,000, or until a CSS selector appears before capture.timeoutOpts.millisecondsbounds the whole request. Fixed waits must end before this deadline.maxAgeMs: 0requests a fresh scrape. If omitted, the tool permits a matching cached result up to three days old.sharedParams.mainContentOnly,sharedParams.includeSelectors, andsharedParams.excludeSelectorshelp select relevant content. Inspect the returned Markdown to confirm that it contains the fields you need.
The same schema accepts sharedParams.actions on paid plans, with up to five ordered steps of type perform, scroll, wait, or waitFor. Use these when the requested extraction needs a particular interaction, such as loading more visible results. Review actions that could submit a form or change external state.
The web-scrape arguments match the request body of unified Scrape, so the same fields work in a direct POST /v1/web/scrape request. The SDKs accept the same fields, with snake_case names in Python and Ruby.
Research structured data with Answers
Use web-answers for sourced research with a requested output shape. Supply a plain-language task, choose a mode explicitly, and pass an example object in json_format. This parameter is not JSON Schema.
The following request asks for product facts from a public demo page. Inspect the returned sources to verify the evidence used:
{
"name": "web-answers",
"arguments": {
"task": "Read https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html and report the product name, displayed price, availability, and brand. Preserve the displayed price and currency symbol. Use null for unsupported information and do not treat the shop name as the product brand.",
"mode": "fast",
"json_format": {
"name": "",
"price_text": "",
"availability": "",
"brand": ""
}
}
}An illustrative json_content object looks like this; current values depend on the source page:
{
"name": "A Light in the Attic",
"price_text": "£51.77",
"availability": "In stock (22 available)",
"brand": null
}Allow null values in your application validator for facts the source does not state. Keeping price_text as displayed also avoids inventing a currency code or silently changing a price's meaning.
Answers does not expose factCheck. Put evidence requirements in the task, preserve returned source URLs, and validate the answer. For one-page JSON Schema extraction, use unified Scrape with formats.json and jsonParams.schema.
Read json_content for the answer and sources for its evidence. The MCP host may expose these in structured content or a text representation; inspect the actual tool response rather than assuming the host's display is the wire format.
Validate the extracted object with your application schema before using it downstream. Preserve the source URLs, request identifier, and collection time alongside it. A correctly shaped object still needs the factual checks appropriate to your application. The Answers reference describes the underlying research operation.
Expand from one page to a bounded crawl
When an answer spans several pages on one site, use web-crawl. Give the agent a starting URL and an explicit scope:
Use Context.dev's web-crawl tool to read at most five pages under
https://docs.context.dev/. Stay within that documentation site, follow
links no more than one level deep, and summarize the pages you retrieved.
Include each source URL and report any incomplete coverage.The tool exposes maxPages, maxDepth, urlRegex, and stopAfterMs for limiting the work. It returns results synchronously and caps maxPages at 500. A page cap is an upper bound, not a promise that every page will be retrieved.
Use web-map when you only need URLs. In the REST API, Map URLs returns indexed URL objects through GET /web/urls. For a large asynchronous collection, use submit-batch, check progress with get-batch, and retrieve completed results with get-batch-results. Recurring checks belong in the monitor tools. Review the proposed scope before starting a batch or recurring monitor.
MCP or the direct REST API
Both interfaces give access to Context.dev operations. Choose the interface that fits the caller and the control you need.
| Decision | MCP | REST API or SDK |
|---|---|---|
| Primary caller | A tool-enabled client or agent | Your application code |
| Setup | Connect the hosted server and authorize access | Configure an API client and server-side credentials |
| Request selection | The host or agent selects a discovered tool | Your code chooses an endpoint or SDK method |
| Response handling | Results enter the client's tool-use workflow | Your code validates, stores, and processes results |
| Typical use | Interactive research and agent-driven lookups | Application features and controlled data pipelines |
MCP does not prevent a custom application from orchestrating tools explicitly. The practical benefit in Cursor and Claude is that discovery, invocation, and the conversation interface are already available. For a service with its own scheduling, storage, and retry policy, the Context.dev API quickstart is a useful starting point.
Troubleshoot the connection and tool calls
| Symptom | What to check |
|---|---|
| Context.dev is missing | Confirm the configuration location, preserve valid JSON, and use the complete URL ending in /mcp. Refresh the client. |
| The server appears but tools are unavailable | Finish OAuth, enable the server or connector for the conversation, and check organization restrictions. |
| Authentication repeats or a call is unauthorized | Reconnect through the client's authentication controls. Inspect the error before assuming it requires an API-key change. |
| The agent answers without calling Context.dev | Name the provider and operation in the prompt, check that its tools are enabled, and resolve any pending approval. |
| Tool arguments are rejected | Compare them with the current tool schema. For example, search takes numResults from 10 to 100. |
| A rendered page is incomplete | Inspect the output, adjust content selectors or waits, and confirm the useful content is publicly accessible. |
| A wait request fails | Keep timeoutOpts.milliseconds well above sharedParams.waitFor so the wait ends before the deadline. |
| Results appear stale | Inspect cache_metadata; request maxAgeMs: 0 when the operation supports it and freshness matters. |
| Requests hit rate limits or timeouts | Reduce concurrent work and request scope. Use bounded retries for transient failures and honor any supplied retry delay. |
| The account has insufficient credits | Review usage and available credits in Context.dev. Repeating the request does not replenish them. |
You can check the hosted service independently:
curl --fail --silent --show-error https://mcp.context.dev/healthOur check returned status: "healthy". This checks service health; a successful authenticated tool call is still needed to verify your connection and account access.
For operation failures, the live server exposes list-logs and get-log. Find the relevant request, then inspect it by request_id. Keep that identifier when contacting support and omit credentials or sensitive page content from shared diagnostics.
Credentials and production use
Use OAuth for the interactive setup above. The production server also accepts API-key authentication through the Authorization header for private integrations. Keep those keys in a secret store, use separate credentials for separate environments, and never place credentials in a URL or committed configuration.
Treat retrieved pages as external data. A page may contain instructions aimed at an agent; that content should not authorize another tool call. Apply your host's approval controls to browser actions, persistent monitor changes, and large batch submissions.
Bound page counts, crawl depth, request duration, and retries. Track tool names, outcomes, request identifiers, source URLs, and cache age so you can distinguish a connection failure from a successful request that returned incomplete information.
The current MCP tools expose request-level browser waits and actions. They do not expose a reusable browser-session or browser-profile management tool. Workflows that need a durable login or detailed browser-state control need a separate browser-automation integration.
FAQs
Do I need Node.js or an npm package for Context.dev MCP?
The hosted Context.dev connection does not require either. Configure https://mcp.context.dev/mcp in a client that supports remote Streamable HTTP and OAuth. Follow that client's own installation requirements separately.
Do I need to generate an API key for Cursor or Claude?
The setup in this guide uses OAuth, so you sign in through your browser. API-key authentication is available for private integrations that supply an Authorization header.
Does every tool call retrieve fresh content?
Some operations can return cached data. For web-scrape, the default cache allowance is three days. Set maxAgeMs: 0 when you need a fresh scrape and inspect the returned cache metadata.
Do MCP calls use my Context.dev credits?
Yes. MCP operations use the same account credits as their corresponding API operations, as described in the MCP authentication and usage guide. A search with page scraping, a crawl, or a batch can involve more work than a single page read.
Do Cursor and Claude get the same tools?
Both connect to the hosted Context.dev server. Client settings, account access, and organization policies can affect which tools are available. The 38-tool count is the production discovery result checked on September 21, 2026; inspect the current tool list when troubleshooting or building new workflows.