Linkup

Linkup Review (2026): Pricing, Verdict & Setup

Linkup gives AI agents live web search through 5 REST endpoints and a hosted MCP server, reaching Claude, Cursor, and LangChain agents. See setup and pricing.

Linkup fits developers who need an agent to ground answers in live web data without building their own crawler. It replaces a DIY scraping stack with one API and a hosted MCP server, backed by $13.2 million in venture funding. Named users include McKinsey, Databricks, and EY on paid enterprise plans.

Linkup is a web search API built for AI agents, reporting a 91-92% F-score on the SimpleQA benchmark. It exposes Search, Fetch, Research, Tasks, and Extract endpoints over REST or a hosted MCP server, letting Claude, Cursor, and LangChain agents pull cited, real-time web results instead of relying on stale training data.

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 specifically for AI agents and LLM applications, made by Linkup SAS, a Paris company founded in 2024 by Philippe Mizrahi, Denis Charrier, and Boris Toledano. Instead of a chat interface, Linkup ships as an HTTP API with Python and Node SDKs plus a hosted MCP server, so a developer wires it directly into an agent's tool set rather than a human opening a browser tab. The company's own published benchmark results claim the top spot among sub-second web search APIs on a widely cited factuality test. The API exposes five endpoints. Search takes a natural-language query and returns ranked URLs, a sourced answer, or structured JSON at standard depth. Fetch converts a known URL into clean markdown quickly, with an option to render JavaScript for client-rendered pages. Research runs an asynchronous multi-source investigation with inline citations, taking longer for deeper reasoning. Tasks batches many Search, Fetch, or Research calls into one submission for bulk workloads. Extract, currently in closed beta, turns a seed page and a query into structured rows matching a JSON schema. Authentication is a bearer API key, and the hosted MCP server (mcp.linkup.so) plugs straight into an MCP client's configuration file. Any agent framework that can call an HTTP endpoint or connect an MCP server can use Linkup: Claude Code, Claude Desktop, Cursor, and any generic MCP client, plus first-party wrappers for LangChain, CrewAI, the OpenAI SDK, and LiteLLM. Reported users include McKinsey, Databricks, EY, Cohere, and Legora, and the sales-agent company Artisan says Linkup is how its agent Ava reaches the web for onboarding and sales research. The natural fit is any RAG pipeline, research agent, or computer-use system that needs to ground answers in live web data instead of a model's training cutoff. Pricing is usage-based with no monthly seats, metered separately across the five endpoints by call volume and reasoning depth; exact tier amounts are on Linkup's public pricing page. Enterprise plans add a dedicated index, IP whitelisting, zero data retention, and a service-level agreement, features usually reserved for self-hosted search infrastructure. Linkup raised a $10 million seed round backed by investors tied to Mistral, Datadog, and Dataiku, after an earlier pre-seed led by Seedcamp, and the company keeps shipping new endpoints, having moved Research to general availability and added Extract as its newest closed-beta capability in 2026.

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.
• SimpleQA-leading accuracy: Linkup reports a 91-92% F-score on the SimpleQA benchmark, which it ranks first among sub-second web search APIs in its own published comparison.
• Native parallel search: Search requests fan out across sources in parallel rather than sequentially, a design Linkup markets as unique among major web search APIs.
• 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.
• Deployment flexibility for regulated data: Beyond the managed API, Private Index and Bring Your Own Cloud let an enterprise keep its proprietary index inside its own infrastructure.
• Batch processing for bulk workloads: The Tasks endpoint groups dozens of calls to the other three 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, in under a second at standard depth.

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: 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 -X POST "https://api.linkup.so/v1/fetch" \
  -H "Authorization: Bearer $LINKUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "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.

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 -X POST "https://api.linkup.so/v1/research" \
  -H "Authorization: Bearer $LINKUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "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":"What is Microsoft'\''s 2024 revenue?","depth":"deep"}},{"type":"fetch","input":{"url":"https://docs.linkup.so","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.

curl -X POST "https://api.linkup.so/v1/extract" \
  -H "Authorization: Bearer $LINKUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "All engineering team members with their name, role, and profile page",
    "url": "https://example.com/team",
    "schema": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "role": { "type": "string" },
        "profileUrl": { "type": "string", "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. New accounts get $20 that refills monthly. Standard Search is $0.005-$0.006 per call, Fetch is $0.001-$0.005, Research ranges $0.25-$2.50 by reasoning depth, Extract is roughly $2-$10 in closed beta. Enterprise adds a custom-priced dedicated index and SLA.

Strengths

• Fast Search response at standard depth, quick enough for synchronous agent turns.
• Usage-based pricing with no monthly seat means small projects only pay for what they call.
• Named enterprise customers (McKinsey, Databricks, EY, Cohere) suggest it holds up at production scale.
• SOC 2 Type II is listed as included rather than gated behind the top enterprise tier.

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.
• No published fixed rate-limit ceiling, which makes capacity planning for high-volume agents harder to pin down in advance.

View the official Linkup skill page