Context.dev
Context.dev provides web scraping, extraction, brand intelligence, monitoring, and structured web data APIs for AI applications.
Verdict
Common use cases
- Enrich lead records with brand logos and colors
- Monitor competitor pricing pages for changes
- Extract design tokens from reference sites
- Scrape product catalogs into structured JSON
- Audit accessibility across marketing pages
Integration
- Vendor
- Context.dev
- Category
- other
- Auth
- API_KEY
- Tools
- 11
- Composio slug
context_dev
Tools
- Extract Structured Web Data
Crawl relevant pages from a website and return data matching a caller-provided JSON Schema and extraction instructions. This is a higher-cost metered call; use SCRAPE_WEBPAGE_MARKDOWN when Markdown is sufficient. The verified one-page call
- Get Brand
Retrieve enriched brand identity, logos, colors, industry, and description using exactly one domain, name, work email, ticker, direct URL, or transaction descriptor. Use SEARCH_BRANDS for inexpensive discovery; this full enrichment normally
- Get Monitor Limits
Return the connected account's plan and current monitor usage versus its monitor limit.
- Get WebDB Usage
Return WebDB credit balance, period consumption, row count, storage, and per-collection usage for an optional time range.
- Get Website Styleguide
Extract a website's colors, typography, spacing, shadows, font assets, and common component styles from either a domain or one direct URL. A successful extraction normally consumes 10 Context.dev credits.
- List Batches
List and filter the connected account's asynchronous web batches from newest to oldest, returning one cursor-controlled page.
- List Monitors
List and filter the connected organization's web monitors, returning one cursor-controlled page.
- List WebDB Collections
List the connected account's WebDB collections and return one cursor-controlled page, including each collection's sources, extraction configuration, status, usage, and timestamps.
- Parse File
Convert an uploaded document, image, source file, or data file into LLM-usable Markdown.
- Scrape Webpage to Markdown
Render one public URL and return its main or CSS-selected content as Markdown. This free-tier tool does not perform paid browser actions. A successful scrape normally consumes one Context.dev credit.
- Search Brands
Prefix-search Context.dev's existing brand index by company name or domain and return up to 10 lightweight matches.
Setup
Setup guide
- 11. Open your Switchy workspace settings and navigate to the Integrations tab. 2. Click 'Add MCP' and select Context.dev from the developer tools category. 3. You'll be prompted to paste an API key — generate one by logging into your Context.dev dashboard, navigating to API settings, and copying the key labeled for production use. 4. Paste the key into Switchy and click 'Connect'. 5. Switchy will verify the key and display your account's monitor and WebDB credit limits. 6. Open any Project and type '@Context.dev get brand for example.com' to test the connection; you should see enriched brand data (logo URLs, hex colors, industry classification) returned in seconds. 7. For schema-driven extraction or styleguide pulls, review your credit balance first using '@Context.dev get webdb usage' to avoid mid-task exhaustion.
What teammates see: by default, memories from Context.dev are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Brand Kit Lookup
@Context.dev get brand identity for acme-corp.com including all logo variants and primary brand colors
Competitor Price Scrape
@Context.dev extract structured data from competitor-site.com/pricing matching this schema: {"plans": [{"name": "string", "price": "number", "features": ["string"]}]}Design System Audit
@Context.dev get website styleguide for design-reference.io and return all typography settings, spacing variables, and box shadows
Monitor Setup Check
@Context.dev list monitors and show my current usage against plan limits
Markdown Page Scrape
@Context.dev scrape webpage markdown from docs.example.com/api-reference and return the full text content
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@Context.dev extract the pricing tiers from stripe.com/pricing into a structured JSON list with plan names, monthly costs, and feature bullets
Extracted 4 pricing tiers from Stripe's site: Starter (free, up to $1M volume), Growth ($25/mo base + volume fees), Scale (custom pricing), and Enterprise (contact sales). Each tier includes feature arrays covering payment methods, fraud tools, reporting depth, and support SLA. The extraction consumed 15 Context.dev credits and returned data matching your schema in ~8 seconds. All fields populated except Enterprise feature details, which required a login wall we couldn't traverse.
This example highlights the Extract Structured Web Data tool, which is metered and higher-cost. You must provide a JSON Schema and clear extraction instructions. Credit consumption scales with page count and complexity; budget accordingly. The MCP cannot bypass authentication walls or execute JavaScript-heavy SPAs without additional configuration.
@Context.dev get the brand identity and logo assets for shopify.com so I can match their color palette in our partner deck
Retrieved Shopify's brand profile: primary green (#95BF47), secondary navy (#212B36), and accent purple (#5C6AC4). Logo variants include full-color SVG, monochrome white, and app icon (512×512 PNG). Industry tagged as E-commerce SaaS. The Get Brand call consumed 1 credit and returned in <2 seconds. Font stack: 'Shopify Sans' (proprietary), fallback to system-ui. No trademark usage guidelines included—consult Shopify's official brand portal for licensing terms.
The Get Brand tool enriches company identity from a single domain, email, or ticker. It's inexpensive (1 credit) and fast, ideal for design research or CRM enrichment. However, it returns publicly available brand data only—proprietary assets or usage rights require vendor permission. Pair with Get Website Styleguide for deeper design-system extraction.
@Context.dev list all active web monitors in our account and summarize which competitor sites we're tracking for pricing changes
Found 7 active monitors: 3 tracking competitor pricing pages (Acme Corp /pricing, Beta Inc /plans, Gamma Co /enterprise), 2 monitoring changelog feeds for feature announcements, 1 watching a regulatory compliance page, and 1 scanning a job board for hiring signals. Pricing monitors trigger on text diffs in cost tables; the Acme monitor fired twice this month when they adjusted their Enterprise tier. Your plan allows 10 monitors total, so 3 slots remain. All monitors check hourly and store 90 days of snapshots.
List Monitors surfaces your account's change-detection setup, useful for competitive intelligence or compliance tracking. The response includes trigger history and quota usage (via Get Monitor Limits). Monitors consume credits per check; high-frequency or large-page monitors can exhaust budgets quickly. This example pairs listing with AI summarization to extract strategic insight from raw monitor metadata.
Use-case deep-dives
When Context.dev beats manual competitor tracking at 5-person scale
A 5-person product team ships a B2B SaaS tool and needs to track three competitors' pricing pages, feature releases, and brand positioning every two weeks. Context.dev's structured extraction and monitors win here because the team can define a JSON schema once (pricing tiers, feature flags, messaging copy) and run scheduled crawls without writing scrapers. The Get Brand and Get Website Styleguide tools pull competitor identity and design tokens in one call, which feeds directly into positioning decks. The threshold: if you're tracking more than eight competitors or need sub-hourly updates, the WebDB credit burn gets expensive and you should build your own scraper. For quarterly competitive reviews at small-team scale, Context.dev is the right call—set it up in an hour and let monitors handle the rest.
Context.dev for inbound lead qualification when you have no data team
A three-person founding team runs an outbound motion and needs to enrich inbound demo requests with company size, industry, and tech stack before the first call. Context.dev's Get Brand tool takes a work email domain and returns enriched identity (industry, description, logos) in one API call, which pipes into your CRM via a Switchy workflow. The Extract Structured Web Data tool can pull a prospect's careers page or about page and return headcount signals or funding stage if you define the schema. This works when you're processing 20-40 leads a week and can't justify a Clearbit contract. The boundary: once you hit 200+ leads a month, per-call metered pricing makes a dedicated enrichment vendor cheaper. For early-stage qualification where speed beats cost, Context.dev gets you from signup form to enriched lead record in under two minutes.
When Get Website Styleguide replaces manual design token extraction
A four-person design agency onboards a new client and needs to document the client's existing brand guidelines, color palette, typography, and component styles before proposing a redesign. Context.dev's Get Website Styleguide tool crawls the client's domain and returns structured design tokens (hex codes, font stacks, spacing scales, shadows) in one call, consuming roughly 10 credits. The output feeds directly into Figma or a style guide doc without manual inspection. This beats screenshot-and-eyedropper workflows when the client has no design system documentation and the agency bills hourly. The constraint: if the client's site uses heavy JavaScript rendering or non-standard CSS variables, extraction accuracy drops and you'll need manual cleanup. For discovery-phase audits where the client pays for speed, Context.dev turns a four-hour manual task into a ten-minute API call.
Frequently asked
What does the Context.dev MCP let me do in Switchy?
It gives your AI agents structured web data extraction, brand enrichment, and website style analysis. You can crawl pages into JSON schemas, pull company logos and colors from domains or emails, extract design systems from live sites, and store scraped data in WebDB collections. Useful when your team needs clean, schema-validated web content without writing scrapers.
Do I need a Context.dev account to use this MCP?
Yes. You'll need an active Context.dev account and an API key. Paste the key into Switchy's connection flow. Most tools are metered—extracting structured data or style guides consumes Context.dev credits from your plan. Check your balance with the Get WebDB Usage or Get Monitor Limits tools before running expensive crawls.
Can it scrape websites that require login or JavaScript rendering?
The MCP doesn't handle authenticated sessions or complex JavaScript apps. It works best on public pages with server-rendered HTML. If you need data behind a login wall or from a React SPA, you'll hit limits. For those cases, use a headless browser tool or the vendor's direct API with custom session handling.
How is this different from just asking Claude to visit a URL?
Claude can fetch raw HTML but can't enforce JSON schemas, extract design tokens, or store results in queryable collections. Context.dev returns validated, structured data—brand metadata with logos, typography rules, or product catalogs matching your schema. You also get monitors and batches for recurring scrapes, which vanilla LLM browsing doesn't offer.
Who on my team should connect the Context.dev MCP?
Whoever owns your Context.dev subscription and understands your credit budget. Structured extraction and style guides are metered calls—one careless batch can burn through your monthly allowance. Connect it under a shared service account if multiple people need access, and brief the team on which tools cost credits before they run workflows.