Linkup review, pricing and verdict

Linkup suits developers who want an agent grounded in live web data without running a crawler. One API and a hosted MCP server cover search, page fetching, and async research, billed per call against prepaid credit. Linkup names McKinsey, SNCF, and Cohere as customers, and its benchmark figures are self-published.

Linkup sells web search to AI agents and reports a 91-92% F-score on SimpleQA in its own benchmarks. It offers Search, Fetch, Research, Tasks, and Extract endpoints over REST or a hosted MCP server, so Claude, Cursor, and LangChain agents can pull cited, current web results. Search and Fetch carry a per-second limit set per organization.

Maker: Linkup SAS · Protocol: MCP · Auth: api key

Compatible agents: Claude Code, Claude Desktop, Cursor, any generic MCP client, LangChain, CrewAI, OpenAI SDK (via wrapper), LiteLLM

Required runtime: None for the hosted API (HTTP only), Node >= 18 for the linkup-mcp-server npx package, Python 3.9+ for the linkup-sdk package

About Linkup

Linkup is a web search API built for AI agents and LLM applications, made by Linkup SAS, a Paris company founded in 2024 by Philippe Mizrahi, Denis Charrier, and Boris Toledano. It ships as an HTTP API with Python and Node SDKs plus a hosted MCP server, so a developer wires it into an agent's tool set instead of a person opening a browser tab. Linkup describes itself as the top performer on OpenAI's SimpleQA factuality test, a claim that rests on its own published benchmark results.

The API has five endpoints. Search answers a plain-language question with ranked links, a cited answer, or JSON in a schema you supply, across four depth settings: flash (an alpha mode Linkup says answers in under 200 ms), fast, standard, and deep. Fetch turns a known URL into clean markdown, with optional JavaScript rendering and a pro mode. Research runs an asynchronous multi-source investigation with inline citations at four reasoning depths. Tasks batches many calls into one submission, and Extract, still in closed beta, turns a seed page and a query into structured rows. Authentication is a bearer API key, and the hosted MCP server at mcp.linkup.so plugs into an MCP client's configuration.

Any agent framework that can call an HTTP endpoint or connect an MCP server can use Linkup, including generic MCP clients, Cursor, and, for terminal work, Claude Code, plus wrappers for LangChain, CrewAI, the OpenAI SDK, and LiteLLM. Linkup names McKinsey, SNCF, Cohere, Legora, Polymarket, and Artisan among its customers, and the sales-agent company Artisan says Linkup is how its agent Ava reaches the web for research.

Pricing is prepaid usage credit with no monthly seats. A sign-up with a professional email gets starter credit that is topped up each month for eligible accounts, and the per-call rates sit in the price notes. The security page lists SOC 2 Type II, ISO 27001, HIPAA, and GDPR, and zero data retention is available on request rather than switched on by default. Linkup raised a $10 million seed round after an earlier pre-seed led by Seedcamp, with angel investors tied to Mistral, Datadog, and Dataiku, and its September 2026 changelog added the flash depth.

Linkup is not the right pick for every team. Research and Extract take minutes and need polling, so they do not fit a synchronous agent turn. Search and Fetch are capped at ten queries per second per organization before a custom plan, and the accuracy figures come from Linkup rather than an independent lab. Teams already standardised on Tavily inside LangChain, teams wanting the neural index of Exa, an answer engine like Perplexity, or a crawler such as Firecrawl for whole-site scraping may be better served elsewhere. Wider comparisons are in the best AI search engines and the best AI for deep research, while the best AI agent builders shows where a search layer fits in an agent stack. If you are unsure which tool suits your job, Smart Match can shortlist options from a few questions.

Key Features

• Five purpose-built endpoints: Search, Fetch, Research, Tasks, and Extract cover sync lookup, page-to-markdown, async deep research, batch processing, and structured scraping in one API.
• Four search depths: Search accepts flash, fast, standard, and deep, from an alpha sub-200 ms mode to multi-step search-then-scrape runs of 5-30 seconds.
• Self-reported SimpleQA lead: Linkup reports a 91-92% F-score on the SimpleQA benchmark and ranks itself first among sub-second web search APIs in its own published comparison.
• Hosted MCP server: One config URL (mcp.linkup.so) wires four MCP tools into Claude Code, Claude Desktop, or Cursor, with no local server process to run.
• Pay per request with x402: Agents can pay in USDC over the x402 protocol with no account, at the same per-call rates with a small minimum per request.
• Data controls for regulated work: Zero data retention is available on request, and enterprise agreements add guaranteed local query processing, multi-region routing, and SSO.
• Batch processing for bulk workloads: The Tasks endpoint groups up to 100 calls to the other endpoints into a single background submission for enrichment jobs.

Use Cases

• Grounding a RAG pipeline in live web data: An agent calls Search with outputType sourcedAnswer to pull cited, current facts instead of relying on stale training data, cutting hallucinated answers.
• Automated investment and deal research: A research agent runs the Research endpoint at reasoningDepth L or XL to synthesize a multi-source report on a company or market in minutes instead of hours of manual browsing.
• Sales and customer enrichment at scale: A sales agent batches up to 100 Search or Fetch calls through Tasks to pull fresh company and contact details for an entire prospect list in one submission.
• Turning a known webpage into agent-readable content: An agent calls Fetch with renderJs true to convert a JavaScript-heavy page into clean markdown before passing it to an LLM for summarization.

Install

claude mcp add --transport http linkup https://mcp.linkup.so/mcp?apiKey=YOUR_API_KEY

Requirements

• A Linkup API key from the dashboard at app.linkup.so (new accounts get $20 in free credit)
• For the hosted MCP server: an MCP-compatible client (Claude Code, Claude Desktop, or Cursor)
• For direct API/SDK use: an HTTP client, or `pip install linkup-sdk` / a Node HTTP client

Actions

Search

Sends a natural-language query and returns ranked URLs, a sourced answer, or structured JSON, with latency from under 200 ms at flash depth to 5-30 s at deep.

curl "https://api.linkup.so/v1/search" \
  -G \
  -H "Authorization: Bearer $LINKUP_API_KEY" \
  --data-urlencode "q=What is Microsoft's 2024 revenue?" \
  --data-urlencode "depth=standard" \
  --data-urlencode "outputType=sourcedAnswer"

• q (string) — required: The natural-language search query.
• depth (string): Search intensity: flash (alpha, lowest latency), fast, standard, or deep.
• outputType (string): Response format: searchResults, sourcedAnswer, or structured.
• structuredOutputSchema (object): JSON schema required when outputType is structured.
• includeDomains (array): Restrict results to up to 100 listed domains.
• excludeDomains (array): Exclude up to 100 listed domains from results.
• fromDate (string): ISO 8601 start date for filtering results.
• toDate (string): ISO 8601 end date for filtering results.
• maxResults (number): Cap on the number of returned sources.
• includeImages (boolean): Surface relevant images in the results.

Fetch

Converts a known URL into clean, LLM-ready markdown in about a second.

curl "https://api.linkup.so/v1/fetch" \
  --oauth2-bearer "$LINKUP_API_KEY" \
  --json '{"url": "https://docs.linkup.so", "renderJs": true}'

• url (string) — required: The page to fetch. Must be a valid HTTP/HTTPS URL.
• renderJs (boolean): Render the page's JavaScript before extraction; required for client-side-rendered pages.
• includeRawHtml (boolean): Return original HTML alongside the markdown for custom parsing.
• extractImages (boolean): Return a separate list of image URLs alongside the markdown.
• mode (string): Fetch mode: standard or pro. Pro costs more per call.
• schema (object): Optional schema for structured output; adds a flat $0.001 per call.

Research

Runs an asynchronous multi-source investigation and returns a cited report or precise answer, taking 2 to 20 minutes depending on reasoning depth.

curl --request POST \
  --url https://api.linkup.so/v1/research \
  --header "Authorization: Bearer $LINKUP_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"q": "Compare the 2024 cloud revenue growth of Microsoft, Amazon, and Google.", "outputType": "sourcedAnswer", "mode": "investigate", "reasoningDepth": "L"}'

• q (string) — required: The research question or topic.
• mode (string): Investigation type: answer, investigate, or research.
• reasoningDepth (string): Thoroughness level: S, M, L, or XL.
• outputType (string): Response format: sourcedAnswer or structured.
• structuredOutputSchema (object): JSON schema for structured output when outputType is structured.

Tasks

Submits a batch of up to 100 Search, Fetch, or Research calls in a single request for bulk or background workloads.

curl --request POST \
  --url https://api.linkup.so/v1/tasks \
  --header 'Authorization: Bearer '"$LINKUP_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '[{"type":"search","input":{"q":"Latest EU AI Act guidance","depth":"deep"}},{"type":"fetch","input":{"url":"https://example.com/pricing","renderJs":false}}]'

• type (string) — required: Which endpoint this task calls: search, fetch, or research.
• input (object) — required: Endpoint-specific parameters matching the corresponding synchronous endpoint.

Extract

Turns a seed URL and a natural-language query into downloadable structured rows matching a JSON schema. Closed beta, request-only access.

AUTH="Authorization: Bearer $LINKUP_API_KEY"
curl "https://api.linkup.so/v1/extract" \
  -H "$AUTH" \
  --json '{
    "q": "All engineering team members with their name, role, and profile page",
    "url": "https://example.com/team",
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "seniority": { "enum": ["junior", "senior"] },
        "profileUrl": { "format": "uri" }
      },
      "required": ["name", "profileUrl"]
    },
    "verifyUrls": true
  }'

• q (string) — required: Natural-language query describing which rows to extract and what each row should contain.
• url (string) — required: The seed URL the extract task starts from.
• schema (object): JSON schema defining the structure of a single extracted record.
• verifyUrls (boolean): Whether URLs found in extracted rows are checked for reachability after extraction.

How to Invoke

Exposed as REST endpoints (Search, Fetch, Research, Tasks, Extract) callable via Python/Node SDK or raw HTTP, and as MCP tools (linkup-search, linkup-research, linkup-get-research, linkup-fetch) once the hosted MCP server at mcp.linkup.so is registered with an API key.

Pricing

Prepaid usage credit, no seats. Signing up with a professional email credits $20, eligible accounts are topped back up to $20 each month, and top-ups of $1,000 or more earn free credits. Search at flash, fast, or standard depth is $0.005 per call ($0.006 for sourced answers or structured output); deep is $0.05 ($0.055). Fetch runs $0.001-$0.01 by mode and JavaScript rendering, plus $0.001 when a schema is set. Research is $0.25 (S), $0.50 (M), $1.50 (L), or $2.50 (XL). Extract in closed beta is usually $2-$10 and needs a $10 minimum balance. Paying per request with USDC over x402 needs no account and has a $0.01 minimum. Enterprise terms are custom. Compare [Tavily](/hub/tools/tavily) and [Exa](/hub/tools/exa) rates before committing.

Strengths

• Flash and fast depths return in well under a few seconds, quick enough for synchronous agent turns.
• Usage-based pricing with no monthly seat means small projects only pay for the calls they make.
• Linkup lists McKinsey, SNCF, Cohere, Legora, and Polymarket among its customers, which points to production use at scale.
• Compliance coverage is broad for a young vendor, and zero data retention can be requested.

Weaknesses

• Research and Extract take several minutes and require polling, so they cannot be used inline in a synchronous agent turn.
• Extract is closed beta and request-only, so it is not yet available to every account.
• Reported benchmark numbers (SimpleQA, SealQA-0, hallucination reduction) come from Linkup's own blog rather than an independent third party.
• Search and Fetch are limited to ten queries per second per organization, so high-volume agents need a custom plan.
• Zero data retention is not on by default, and queries may be processed in the US, EU, Canada, or APAC unless an enterprise agreement fixes the region.

View the official Linkup skill page