Announcing the Context.dev Integration for Cursor | Context.dev

Today we're launching the Context.dev plugin for Cursor.

One install gives Cursor a complete Context.dev setup: an OAuth-connected MCP server with 34 typed tools, 11 focused skills, four slash commands, and two rules for choosing the right tool and handling credentials safely.

That means Cursor can search the current web, scrape a known page, crawl a site, extract schema-shaped JSON, parse a local document, retrieve brand intelligence, capture a screenshot, monitor a website for changes, or run a large asynchronous batch without you wiring up a separate tool for every job.

The plugin also teaches Cursor how to build against the Context.dev REST API and SDKs when the task is application development rather than an interactive lookup.

No hand-written MCP configuration. No API key pasted into Cursor. No guessing which web operation fits the request.

More than an MCP connection

Cursor plugins package the context and capabilities an agent needs into one install. The Context.dev plugin uses four of those building blocks together:

• MCP server: connects Cursor to the production Context.dev server at https://mcp.context.dev/mcp
• Skills: give the agent focused workflows for search, scraping, crawling, extraction, parsing, brand data, monitors, batches, direct API development, OAuth setup, and Logo Link
• Commands: add /search-web, /scrape-url, /extract-web-data, and /brand-colors as direct shortcuts
• Rules: route live-web work to the narrowest appropriate tool and keep private credentials out of client-side code

The distinction matters. An MCP server makes tools callable, but the agent still needs to know when to search instead of scrape, when a crawl is too broad, how to define a useful extraction schema, and which operations change account state. The bundled skills and rules provide that operating context.

For example, if you provide an exact URL and ask for its contents, the plugin steers Cursor toward web-scrape-markdown. If you do not know the source yet, it uses web-search. If the answer spans several pages on one site, it can use web-crawl. If the output needs to feed code or a database, it can switch to web-extract and return an object shaped by your JSON Schema.

Add Context.dev to Cursor

Open the Context.dev Marketplace listing and install the plugin, or run this in Cursor:

/add-plugin context-dev

Then open Cursor Settings → Tools & MCP, enable the context server, and select Connect or Authenticate. Cursor opens the Context.dev sign-in flow in your browser.

The hosted MCP connection uses OAuth, so you do not need to copy a private Context.dev API key into mcp.json, a prompt, or a project file. After authorization, return to Cursor and confirm that the server lists its tools.

A simple read-only test is:

Use Context.dev to scrape https://www.context.dev and return the page title.

Cursor should call web-scrape-markdown and answer from the live result.

Search, scrape, and crawl with the right scope

Web research tends to become unreliable when every request is treated as the same generic fetch. The plugin gives Cursor separate workflows for source discovery, single-page retrieval, URL discovery, and multi-page collection.

Use live search when the agent needs to find the source first:

Use Context.dev to find Cursor's latest official product announcements and cite the source URLs.

Use scraping when you already know the page:

Use Context.dev to scrape this pricing page and summarize every plan and limit.

For readable content, Cursor can request clean Markdown. It can also retrieve rendered HTML, extract page images, or capture a screenshot when the task needs the DOM, assets, or pixels rather than prose.

For site-level work, the crawl skill separates discovery from collection. web-scrape-sitemap can find and rank relevant URLs without fetching every page body. web-crawl can then retrieve a bounded set of linked pages with their source URLs preserved.

That gives Cursor enough control to answer questions such as:

• Find every authentication guide in a documentation site and compare their setup steps
• Collect pricing, security, and integration pages for a vendor review
• Map a changelog or blog before selecting the pages relevant to a release
• Read a focused section of a large site without flooding the context window with unrelated pages

Return structured answers, not a pile of pages

Many agent workflows need predictable data rather than a summary. The context-extract skill teaches Cursor to define the smallest useful JSON Schema, describe ambiguous fields, preserve missing values, and call web-extract for schema-shaped output.

You can ask:

Use Context.dev to extract every open engineering role from this careers site as JSON with title, location, team, and application URL.

The result is ready for the next step in a workflow, whether that is validation, application code, a database write, or a comparison across companies.

The plugin also includes parse-document for local files. Cursor can convert PDFs, Office documents, spreadsheets, presentations, images, source files, HTML, and plain text into clean Markdown, with OCR available when a scanned document requires it.

That makes it possible to combine public web context with material already in the workspace. A procurement task can inspect a vendor's current security pages and an uploaded agreement. A research task can compare a live product page with a spreadsheet. A support task can read the latest docs alongside a customer-provided PDF.

Bring brand intelligence into coding workflows

Context.dev's brand capabilities are included in the same connection. Cursor can retrieve a visual brand profile for a domain or structured brand data for workflows that start from a domain, company name, work email, stock ticker, ISIN, transaction descriptor, or direct URL.

Depending on the task, the response can include logos, colors, descriptions, social profiles, links, address data, stock information, and industry classification. Separate tools can inspect a website's style guide and font usage or classify a company with NAICS and SIC codes.

That is useful when the code itself needs real brand data:

• Personalize onboarding from a customer's work domain
• Add company logos and colors to a CRM or dashboard
• Inspect a customer's design system before generating a branded asset
• Turn a transaction descriptor into a recognizable merchant
• Populate a company profile without inventing details from model memory

For high-volume logo rendering in browser UI, the bundled logolink skill takes a different path. It guides Cursor to use Context.dev Logo Link with a front-end-safe public client ID rather than exposing a private API key or calling the full brand API from client code.

Monitor changes and move large jobs out of the chat turn

Some web tasks are recurring, and others are simply too large for one synchronous agent turn.

The monitor skill covers ongoing website-change tracking. Cursor can create a recurring monitor, inspect its configuration and run history, retrieve detected changes, or pause and update an existing monitor. Because creating, updating, running, and deleting monitors changes persistent account state, the plugin tells the agent to perform those actions only when the user clearly requests them.

The batch skill handles large asynchronous jobs. submit-batch can process a fixed collection of up to 25,000 URLs or start a large crawl, while the remaining batch tools let Cursor inspect progress, page through results, cancel active work, or delete a finished record.

Those workflows make requests like these practical:

• Watch a competitor's pricing page and review only material changes
• Track a documentation site for newly published pages
• Scrape a large URL inventory without holding one chat request open
• Submit a site crawl, return to other work, and retrieve the completed results later

The plugin distinguishes read-only inspection from operations with side effects. It also uses idempotency guidance for batch submission so a network retry does not silently create duplicate work.

Build with the API without mixing up authentication

Interactive Context.dev tool calls inside Cursor use the plugin's OAuth connection. Application code that calls the Context.dev REST API or an SDK directly uses a different authentication model.

When you ask Cursor to integrate Context.dev into a codebase, the bundled context-dev development skill guides it through the public REST endpoints and the TypeScript, Python, Ruby, Go, and PHP SDKs. In that workflow, the application reads a private API key from a server-side CONTEXT_DEV_API_KEY environment variable.

The plugin keeps those two paths separate:

• Using Context.dev from Cursor: authenticate the context MCP server with OAuth
• Building Context.dev into your application: use a private API key on the server, never in browser code or source control

This lets Cursor both use Context.dev as an agent tool and help you implement Context.dev correctly in the product you are building.

Get started

Install Context.dev from the Cursor Marketplace, then connect the context MCP server through Cursor's browser-based OAuth flow.

You can start with a command such as /search-web or simply describe the outcome:

Use Context.dev to research the latest changes to this dependency, read the primary sources, and summarize anything that affects this repository.

Cursor now has the live-web tools and the operating instructions to carry that request from source discovery through a grounded answer.