Skip to content
unlob

Web search API for AI agents

Ten links aren’t ten sources.

unlob counts real sources, not copies — and tells your agent when there isn’t enough to answer.

10,000 free credits a month · no card · MCP-ready

Q: Has the merger been approved?

A search API returns

10 links

  1. prnewswire.com
  2. reuters.com
  3. finance.yahoo.com
  4. marketwatch.com
  5. industrywatch.blog
  6. investing.com
  7. benzinga.com
  8. morningstar.com
  9. nasdaq.com
  10. stocktitan.net

unlob counts sources, not copies

  1. Press releaserepeated on 6 sites
  2. Reuterswire story, 3 copies
  3. An industry blogoriginal

not enough3 sources, none of them official.

Your agent says “I couldn’t confirm that yet” — instead of “according to multiple reports”.

An illustrative example. The live one is just below.

Live, not a mock-up

Ask it something. Then raise the bar.

This is the real API, answering now. Pick a question, then require more independent sources, an official source or more recent evidence — and watch the verdict change from enough to not enough.

The problem

Your agent can’t tell ten links from ten sources.

A search API hands your agent links and leaves the judgement to the model. It can’t see that eight of them are the same press release, that none is an official source, or that the newest is two years old — so it sounds just as confident either way.

With a plain search API

  • Ten links, ranked. Eight are reprints of one press release.
  • The model has to fetch and compare them to notice — and usually doesn’t.
  • “According to multiple reports…” — all of them the same report.
  • No signal for “there isn’t enough here”, so it answers anyway.

With unlob

  • Two sources, with the reprints grouped under the one they copied.
  • Each labelled: official, primary, or repeating someone else.
  • A verdict by your rule: enough, not enough, too old or nothing found.
  • When it’s not enough, your agent says so — and knows what to try next.

The difference is whether your agent can say “not enough”.

What changes

Answers your agent can stand behind.

  1. 01

    It says “not enough” instead of guessing.

    You set the bar: how many independent sources, which kinds, how recent. Every call comes back as enough, not enough, too old or nothing found — with what to try next. Your agent can decline to answer when it should, instead of sounding just as sure either way.

  2. 02

    It counts sources, not copies.

    A wire story running on seventeen sites is one source, and so is a press release everyone reprinted. Each source is labelled — official, primary, or repeating someone else — so the citations your agent gives hold up when somebody checks. Less duplicate text reaches your context window, too.

  3. 03

    Same question, same verdict.

    No model decides whether the evidence is enough; a documented rule does. So you can test it in CI, and when a reviewer asks where an answer came from, you can show what was searched and what was missing.

GET /groundobjective="UK AI regulation position this week"

What the web holds

24 copies · 17 hosts

  1. 6 copies · 4 hostsgov.ukofficial · original
  2. 14 copies · 10 hostsThomson Reuterssecondary · wire
  3. 4 copies · 3 hostsA trade publicationsecondary · original

collapsed by origin and owner, not by host

receipt

status: sufficient

origins
3
hosts
17
copies
24
  • freshnesswithin 7d · newest 37 min
  • missingprimary
  • context1,420 / 3,000 tokens
  • billed5 credits
An illustrative example of one call, not a measurement: 24 copies on 17 sites are three sources, and the verdict says what is still missing.

Drop it in

One call, or two tools over MCP.

Send the question and what counts as enough. Read the verdict first; if it’s enough, answer from the sources it returns.

curl -G https://api.unlob.com/ground \
  -H "x-api-key: $UNLOB_API_KEY" \
  --data-urlencode "objective=UK AI regulation position this week" \
  -d max_age=7d \
  -d min_independent_origins=2 \
  -d token_budget=3000
import os, requests

g = requests.get(
    "https://api.unlob.com/ground",
    headers={"x-api-key": os.environ["UNLOB_API_KEY"]},
    params={
        "objective": "UK AI regulation position this week",
        "max_age": "7d",
        "min_independent_origins": 2,
        "token_budget": 3000,
    },
).json()

# Read status first. partial is never complete.
if g["status"] == "sufficient":
    context = [e["hit"]["snippet"] for e in g["evidence"]]
else:
    print(g["coverage"]["known_gaps"], g["next_actions"])
const url = new URL("https://api.unlob.com/ground");
url.search = new URLSearchParams({
  objective: "UK AI regulation position this week",
  max_age: "7d",
  min_independent_origins: "2",
  token_budget: "3000",
}).toString();

const g = await fetch(url, {
  headers: { "x-api-key": process.env.UNLOB_API_KEY! },
}).then((r) => r.json());

// Read status first. partial is never complete.
if (g.status !== "sufficient") {
  console.log(g.coverage.known_gaps, g.next_actions);
}

Or connect over MCP

Two tools in Claude Code, Cursor or any MCP client.

The grounding profile lists only what an agent needs to ground a task, so far less tool schema rides along in every request. The full profile adds the six graph operations.

MCP profiles ↗Per-client setup ↗The Agent Skill ↗

MCP client configjson
{
  "mcpServers": {
    "unlob": {
      "type": "http",
      "url": "https://api.unlob.com/mcp?profile=grounding",
      "headers": { "x-api-key": "ulb_your_key_here" }
    }
  }
}

Built for

Agents whose answers get checked.

If someone reads your agent’s answer and asks “says who?”, this is for you — if it just looks up library docs, a plain search API is fine. Start from where you are: every route ends in a test on your own tasks, with the cases where unlob doesn’t fit reported as plainly as the ones where it does.

Why not Exa or Tavily?

They find pages. We tell your agent whether they’re enough.

Exa, Tavily and Parallel are good at returning results, and are racing to generate answers on their own models. None of them tells your agent whether what it found is enough to act on.

Where they win

  • Broader products — research agents, crawling, monitors.
  • More scale, more customers, more funding.
  • If you want an answer written for you, they will write one.

Where unlob wins

  • A verdict on the evidence, by a rule you set.
  • Sources counted once, not once per copy.
  • Your model does the reasoning, not ours.
  • 10× cheaper than Exa’s Instant search.

For whoever signs off on it

Built to be depended on.

The search layer is the hardest part of an agent stack to swap later. These are the things to check.

Index
Our own.No upstream search engine can retire, reprice or rate-limit the layer your agent depends on — as the Bing API’s users found out.Why an own index
Verdict
A documented rule, not a model.The same request over the same index gives the same verdict, so behaviour can be tested and explained.How the verdict is decided
Model
Yours.No generated answer and none of our models in the loop, whichever model you run.How it works
Operations
What exists today, and what doesn’t yet.Limits, failure behaviour, key handling and where it runs — with the controls still coming marked as coming.Security and operations

Price

Priced like infrastructure.

On our own index, with no fee to an upstream search engine in the bill.

Dollars per 1,000 comparable web searches, log scale; each price is the vendor’s cheapest comparable mode, named beside it, and the multiple is against unlob Scale. Each competitor figure is read from the vendor's own pricing page; the oldest read is 7 October 2026.

FAQ

Frequently asked questions

What is unlob?

A web search API for AI agents. Instead of a list of links, one call returns the sources that actually support an answer — copies of the same story counted once, each source labelled official, primary or secondary — and a verdict: enough to answer, not enough, too old, or nothing found. Your agent reads the verdict and either answers, citing the sources, or says it does not know. There is no generated answer; the reasoning stays with your model.

What happens when there is not enough evidence?

The call says so, and says why — too few independent sources, no official or primary source, nothing recent enough, or nothing at all — with what to try next. That is the point: an agent that can tell "not enough" from "enough" can decline to answer instead of answering from whatever came back.

Can’t my model work this out itself?

Not reliably. To see that eight links are one press release it has to fetch and compare all of them, in context, on every run — and it will judge differently each time. unlob does that comparison once, with a documented rule, so the same question gets the same verdict.

How is this different from Exa, Tavily or Parallel?

They return search results, and increasingly generate answers on their own models. Neither tells your agent whether what it found is enough to act on. They win on breadth of product — research agents, crawling, monitors — and on scale and customer base; every comparison page on this site says where. unlob wins on the verdict, on counting sources rather than copies, on keeping the reasoning in your model, and on price.

What counts as an independent source?

Not a website. Copies of the same wire story, the same press release or the same article are grouped into one source, and two outlets owned by the same group count once. So "three independent sources" means three owners reporting it, not three URLs. The rule is documented in full on the grounding page.

Does unlob have its own web index, or does it resell Google results?

Our own. We crawl the open web and serve from the index we built, so no upstream search engine can deprecate, reprice or rate-limit the layer your agent depends on.

Does it work with MCP and my framework?

Yes. Over MCP, the grounding profile is two tools — ground and get_document — for Claude Code, Cursor or any MCP client. Over HTTP it is one call, with copy-paste setups for LangGraph, the OpenAI Agents SDK, PydanticAI, the Vercel AI SDK and LlamaIndex. No SDK to adopt.

What does the free tier include?

10,000 credits a month, no card. A ground call is 5 credits and a plain search 1 credit. It hard-caps at its monthly credits rather than billing you by surprise.

Try it on your own questions

10,000 credits a month, no card, no sales call. One magic link creates your account and your first API key.

Your first callbash
# One magic link: account, org and your first key
export UNLOB_API_KEY=ulb_your_key_here

curl -G https://api.unlob.com/ground \
  -H "x-api-key: $UNLOB_API_KEY" \
  --data-urlencode "objective=UK AI regulation position this week"
API and MCP reference ↗