This skill teaches you how to use Linkup's search and fetch tools effectively. Linkup is an agentic web search API — it interprets natural language instructions and executes retrieval steps to return accurate, real-time web data. Read this skill before making any Linkup search or fetch call.

1. How to Construct a Query

Your Linkup query should focus on data retrieval, not answer generation. Tell Linkup what to find and where to look. Do the reasoning and synthesis yourself after receiving the results.

Before writing your query, reason through three questions in order. Each answer constrains the next.

Step 1: What inputs do I already have?

Step 2: Where does the data I need live?

Step 3: Do I need to chain steps sequentially?

When uncertain, default to deep.

Worked Examples

Inputs: company name only, no URL
Data needed: pricing details (lives on a full page, not in snippets)
Sequential: yes — need to find the pricing page first, then scrape it
→ depth="deep"
→ query: "Find the pricing page for {company}. Scrape it. Extract plan names, prices, and features."

Inputs: company name only, no URL
Data needed: latest funding round amount (lives in search snippets)
Sequential: no
→ depth="standard"
→ query: "Find {company}'s latest funding round amount and date"

Inputs: a specific URL (https://example.com/pricing)
Data needed: pricing details from that page
Sequential: no — I already have the URL
→ depth="standard" or /fetch
→ query: "Scrape https://example.com/pricing. Extract plan names, prices, and included features."

Inputs: a company name
Data needed: the company's ICP, inferred from homepage + blog + case studies
Sequential: yes — need to find pages, then scrape them, then synthesize
→ depth="deep"
→ query: "Find and scrape {company}'s homepage, use case pages, and 2-3 recent blog posts. Extract: industries mentioned, company sizes referenced, job titles targeted, and pain points addressed."

2. Choosing Search Depth

Linkup supports two search depths. Your answers from Section 1 determine which to use.

Standard (depth="standard") — €0.005/call

• Can run multiple parallel web searches if instructed
• Can scrape one URL if provided in the prompt
• Cannot scrape multiple URLs
• Cannot use URLs discovered in search results to scrape them

Deep (depth="deep") — €0.05/call

• Executes up to 10 iterative retrieval passes, each aware of prior context
• Can scrape multiple URLs
• Can use URLs discovered in search results to scrape them
• Supports sequential instructions (outputs from one step feed the next)

When uncertain, default to deep.

Cost tip: 3–5 parallel standard calls with focused sub-queries is often faster and cheaper than one deep call. Reserve deep for when you need to scrape multiple URLs or chain search → scrape.

3. Choosing Output Type

Default choice: Use searchResults when you will process the results. Use sourcedAnswer when the user needs a direct answer. Use structured when downstream code needs to parse the output.

4. Writing Effective Queries

Rule of thumb: The level of complexity and the choice of depth of your query ofen depends on the use case:

• Conversational chatbot where low latency is important: keep prompts simples, keyword style, standard depth
• Deep researcher: more detailed more, leverage scraping, deep depth

Be specific

Add context: dates ("Q4 2025"), locations ("French company Total"), versions ("since React 19"), domains ("on sec.gov").

Keyword-style for simple lookups

Short keyword queries work fine for straightforward facts:

"Bitcoin price today"
"NVIDIA Q4 2024 revenue"
"Anthropic latest funding round"

Instruction-style for complex extraction

When you need specific extraction or multi-step retrieval, write your query as a natural language instruction — what to find, where to look, what to extract:

"Find Datadog's current pricing page. Extract plan names, per-host prices, and included features for each tier."

"Find Acme Corp's investor relations page on acme.com. Extract the most recent quarterly revenue figure and year-over-year growth rate."

Request parallel searches for breadth

For broad research, explicitly ask for multiple passes. This works even in standard:

"Find recent news about OpenAI. Run several searches with adjacent keywords including 'OpenAI funding', 'OpenAI product launch', and 'OpenAI partnership announcements'."

Or issue 3–5 separate standard calls from your agent, each with a focused sub-query:

Query 1: "Datadog current annual recurring revenue from latest earnings"
Query 2: "Datadog number of customers over $100k ARR"
Query 3: "Datadog net revenue retention rate from investor presentations"

Sequential instructions (deep only)

When you need to discover a URL then extract from it, be explicit about the sequence:

"First, find the LinkedIn company page for Snowflake. Then scrape the page and extract: employee count, headquarters, industry, and company description."

Scrape a known URL (standard: one URL max)

If you already have a URL, include it in the prompt. In standard, this is limited to one URL per call:

"Scrape https://example.com/pricing. Extract all plan names, prices, and feature lists."

You can combine one scrape + search in a single standard call:

"Scrape https://linkup.so. Also search for articles mentioning Linkup clients. Return a list of known clients with the source of each."

To scrape multiple URLs, or to scrape URLs discovered during search, use deep.

5. Using the /fetch Endpoint

When your agent already knows the exact URL, use /fetch instead of /search. It's faster, cheaper, and purpose-built for single-page extraction.

Default to renderJs: true. Many sites load content via JavaScript. The latency tradeoff is almost always worth the reliability gain.

6. Advanced Techniques

LinkedIn extraction (if you have the LinkedIn URL of the person/company/post -> standard)

• return the linkedin profile details of {{linkedin_url}}
• return the last 10 linkedin posts of {{linkedin_url}}
• return the last 10 linkedin comments of {{linkedin_url}}
• extracts the comments from {{linkedin_post_url}}

LinkedIn extraction (if you need to search for the LinkedIn URL first -> deep)

First find LinkedIn posts about context engineering.
Then, for each URL, extract the post content and comments.
Return the LinkedIn profile URL of each commenter.

Date filtering and domain filtering

Use fromDate and toDate to limit results to a time window:

Query: "Find news about Anthropic product launches"
fromDate: "2025-01-01"
toDate: "2025-03-31"

Use includeDomains to focus on specific sources, or excludeDomains to remove noise:

Query: "Find Tesla's latest quarterly earnings data"
includeDomains: ["tesla.com", "sec.gov"]

Instructions: for both domain filtering and date filtering, only use if implicitly or explicitly instructed to do so.

7. MCP Setup

Two tools: linkup-search (query, depth) and linkup-fetch (url, renderJs).

Auth format (v2.x): apiKey=YOUR_API_KEY in args. Old v1.x env format no longer works.

Quick Reference

STANDARD:  €0.005. Parallel searches ✓  Scrape one provided URL ✓  Scrape multiple URLs ✗  Chain search→scrape ✗
DEEP:      €0.05.  Iterative searches ✓  Scrape multiple URLs ✓   Chain search→scrape ✓
UNCERTAIN: Default to deep.
OUTPUT:    searchResults (raw sources)  |  sourcedAnswer (natural language)  |  structured (JSON schema)
FETCH:     Single known URL → /fetch with renderJs: true
QUERIES:   Keyword for simple lookups. Instruction-style for complex extraction. Be specific.
COVERAGE:  "Run several searches with adjacent keywords" for breadth (works in standard).
CHAINING:  "First find X, then scrape X" — deep only.