FreeSerp: A Free Web Search API Your AI Agent Can Actually Sign Up For (Because There Is Nothing to Sign Up For)

Every search API on the market wants an account, a key and a credit card — three things an autonomous agent cannot produce. FreeSerp removes all three and hands back ranked JSON over 21 million live sites, with an LLM summary attached to every result. Here is everything it does, how the index behind it is built, and where its edges are.

The API Key Is the Bug

Give an AI agent a task that needs the live web — find companies shipping voice agents this month, check whether this domain is a real business or a parked page, tell me who else works in this space — and it stops dead at the same place every time. Not at the reasoning. At the signup form.

The search APIs an agent would reach for all assume a human sits behind them. SerpApi, Serper, Tavily, Exa, Brave, Google's Programmable Search, Bing's Web Search API: every one of them starts with an account, a dashboard, a key to copy, and in most cases a card on file and a per-request meter running. That is a perfectly sane business model for a human developer. For an agent it is an unmovable wall, because an agent cannot register, cannot accept terms, cannot rotate a leaked key and cannot top up a balance at three in the morning.

So the key does not just cost money. It puts a human back in the loop of a system whose entire point was to not need one.

FreeSerp is a direct answer to that: a web search API with no key, no signup, no account, no quota plan and no billing, reachable as a single GET request or as a hosted MCP server. An agent can decide it needs search and be searching in the same step.

What FreeSerp Actually Is

FreeSerp is a search interface over an independent web index — not a scraper sitting in front of Google. That distinction shapes everything else about the product, so it is worth being precise about it up front.

Most "SERP APIs" are proxies. You ask them for a query, they run it against Google or Bing through a pool of residential proxies, parse the resulting HTML and hand you back a structured copy of somebody else's ranking. That works, it is expensive, it is legally awkward, and it breaks whenever the target changes its markup.

FreeSerp queries an index built and maintained in-house: newly registered domains are pulled in daily, probed for liveness, crawled, summarised by a language model, categorised, and scored for authority on an internal web-graph. What comes back is not Google's opinion of a page — it is a structured record of the site itself.

Those figures are the live snapshot at the time of writing; the index moves every day and the service publishes its own numbers (see Statistics, below). Roughly a quarter of a million new live sites enter it in a typical week, and over eleven million entered in the last thirty days.

The Whole API Is One GET Request

There is one endpoint. It takes query parameters and returns JSON. That is the complete surface area.

curl 'https://freeserp.ai/api.php?q=ai+chatbot&size=3'

It also answers at /api, responses carry Access-Control-Allow-Origin: * so browser code can call it directly with no proxy, and results are edge-cached for about thirty seconds. In Python it is four lines:

import requests

r = requests.get('https://freeserp.ai/api.php', params={
    'q': 'voice agent',
    'ai_startups': 1,
    'sort': 'went_live',
    'order': 'desc',
    'size': 5,
})
for hit in r.json()['results']:
    print(hit['domain'], '—', hit['ai_summary'][:120])

And in the browser, with no server in between:

const r = await fetch('https://freeserp.ai/api.php?' + new URLSearchParams({
  q: 'vector database', ai_startups: 1, sort: 'dr', order: 'desc', size: 10,
}));
const { results } = await r.json();
results.forEach(h => console.log(h.domain, h.dr, h.ai_summary));

A response echoes back everything it did with your request, which matters more than it sounds — an agent that can read filters, total and took_ms can tell the difference between no results and my filter was wrong.

{
  "ok": true,
  "query": "ai chatbot",
  "total": 48213,
  "count": 3,
  "from": 0, "size": 3,
  "sort": "relevance", "order": "desc",
  "filters": { "real_site": "1" },
  "took_ms": 34, "engine_ms": 21,
  "results": [
    {
      "domain": "example.ai",
      "url": "https://example.ai",
      "title": "Example — AI chatbot for support",
      "ai_summary": "Example is an AI chatbot platform that …",
      "category": "ai",
      "ai_categories": ["AI Chatbot & Assistant"],
      "ai_source": "nextjs",
      "dr": 41,
      "went_live": "2026-08-22",
      "first_seen": "2026-07-10",
      "tld": "ai", "http_status": 200,
      "content_length": 8123, "html_size": 40213,
      "_score": 3182.4
    }
  ]
}

Every Result Arrives Pre-Digested for a Language Model

This is the part that separates FreeSerp from a SERP proxy in day-to-day use. A classic search API gives an agent ten blue links: a URL, a title, and a two-line snippet chopped out of the page. To learn anything the agent then has to fetch each page, fight the HTML, and burn tokens on navigation menus and cookie banners.

FreeSerp does that work once, on ingest, for the whole index. Every record carries ai_summary — a factual, model-written overview of what the site is and does — so the agent can read the result set directly and only fetch the two or three pages it actually needs.

• ai_summary An LLM-generated description of the site, written from the crawled page text. Readable as-is; no scraping step required.
• ai_categories A multi-valued sub-niche taxonomy — "AI Agents & Autonomous", "Code & Dev Tools", "Image Generation", "AI Infrastructure & API" and about thirty more.
• ai_source The builder or stack signal detected on the page: wordpress, shopify, wix, webflow, nextjs, react, joomla, drupal, elementor — plus the AI-builder markers lovable, v0, bolt, base44 and the heuristic ai_likely.
• dr Domain Rating 0–100, an authority proxy computed on FreeSerp's own web-graph and calibrated against Ahrefs, not fetched live from a third party.
• went_live / first_seen When the liveness probe first confirmed the site reachable, and when the domain first entered the discovery feed.
• real_site 1 for a genuine content site, 0 for parked, empty or erroring. Real-only is the default; parked domains are opt-in.
• content_length / html_size / http_status / webserver / ip / tld The technical shape of the homepage, all of it filterable and sortable.

If the summary is not enough, content=1 returns the full extracted page text alongside it, and content_max=4000 caps that text so a page of results does not blow a context window.

curl 'https://freeserp.ai/api.php?q=rag+pipeline&content=1&content_max=4000&size=3'

Filter and Sort on Every Field — Including With No Query at All

FreeSerp is not only a search box. Because every field in the record is indexed as a first-class field rather than buried in a snippet, the API doubles as a browsable database of the live web. Drop q entirely and it becomes pure filter-and-browse mode.

Sorting works on relevance, domain, category, ai_categories, ai_source, dr, went_live, first_seen, real_site, tld, http_status, content_length, html_size, webserver and ip. That combination is what makes the odd queries possible: the heaviest pages on Shopify by text size, every .ai domain that went live yesterday ordered by authority, sites returning a 403 sorted by Domain Rating.

Ranking on relevance is deliberately not pure text score. FreeSerp multiplies the text match by the domain's authority — _score × (1 + dr / 20) — so a well-matched page on a domain nobody links to does not outrank a well-matched page on one that everybody does. When there is no q at all, relevance is meaningless, and the API silently falls back to Domain Rating descending, then newest live.

Domain queries get special treatment. Type a full domain and it is boosted by a factor of 5,000 straight to position one; type a bare name and the .com, .ai, .io, .app, .dev and .co variants are boosted in that order. That turns the search endpoint into a lookup endpoint for free:

# Is this domain real, and what is it?
curl 'https://freeserp.ai/api.php?q=mynewstartup.ai&all=1&size=1'

The ai_startups Filter, and Why It Exists

category=ai is a keyword heuristic: it fires when a page talks like an AI product. It is deliberately wide, and being wide it is noisy — it also flags AI-flavoured Shopify shops, AI-themed directories, and a depressing number of casinos that discovered the word "neural".

ai_startups=1 is the cleaned-up version. It keeps only records whose LLM-assigned sub-niche is one of fifteen genuine AI-product categories, and explicitly excludes anything in the gambling bucket:

• AI Agents & Autonomous · Code & Dev Tools · AI Infrastructure & API
• AI Automation & Workflows · LLM & Prompt Tools · AI Search & Answers
• AI Website Builder · No-code / App Builder · Image Generation
• Video Generation · Voice & Text-to-Speech · Data & Analytics
• Research & Science · Design & UI · Chatbot & Assistant

Everything else in the taxonomy — E-commerce, Directory / Aggregator, Marketing & Ads, Sales & CRM, Lead Gen & Outreach, Finance & Trading, Healthcare & Medical, Education & Tutoring, "Other AI" — stays queryable through ai_categories but is treated as noise for startup discovery. The result is a much smaller, much truer surface: 33,429 AI startups against 78,674 domains that merely trip the broad ai keyword.

This is the single most useful query on the service, and it is worth committing to memory:

curl 'https://freeserp.ai/api.php?ai_startups=1&ai_categories=AI%20Agents%20%26%20Autonomous&from_date=2026-09-01&sort=went_live&order=desc'

New AI agent companies, in launch order, this month. No dashboard, no export, no key.

What the Index Looks Like From the Inside

FreeSerp publishes its own composition, which is unusual and useful — you can see what you are querying before you query it. A snapshot at the time of writing:

Where the AI sits

What the web is built on

The ai_source distribution is an accidental census of the modern web stack. Among sites where a stack could be detected: WordPress 2,043,029 · the heuristic ai_likely marker 542,272 · Wix 315,437 · Next.js 249,286 · Elementor 80,425 · Joomla 48,091 · Shopify 41,924 · Drupal 31,719 — against 3,131,930 explicitly classified not_ai.

Authority is brutally concentrated

The Domain Rating histogram across the whole index tells a story that anyone selling "high DR guest posts" would rather you did not see:

Average DR across the index is 8.6. Above DR 50 there are roughly eight thousand domains in twenty-one million. Above DR 70, one hundred and thirty-eight.

The long tail by TLD

.com 7,894,035 · .org 677,100 · .de 527,027 · .uk 522,095 · .net 405,441 · .ru 387,151 · .br 303,834 · .au 261,843 · .fr 257,809 · .nl 242,748 · .it 238,815 · .pl 196,014. The index is global — every TLD, every language, no regional bias baked in.

And one oddly specific corner

Gambling gets its own classification pass, splitting 806,182 betting and casino domains into operators (5,195 originals), affiliates (4,517) and everything else. It is a niche capability, but it is the kind of thing an index built by people who work in search ends up needing.

A Live Statistics Endpoint That Costs You Nothing

All of the numbers above come from a single call. A background robot recomputes the whole snapshot every thirty minutes and stores it, so reading it is instant and puts no load on the search cluster.

curl 'https://freeserp.ai/api.php?stats=1'

The payload carries totals (real sites and all sites), new-site counts for today, yesterday, seven days and thirty days, AI-startup totals, the full category and sub-niche breakdowns, top builders, top TLDs, the DR histogram, a thirty-day daily curve, the gambling split, and a pipeline block showing how much work is still queued inside the ingest system — summaries pending, sites that went live today, probes due.

For an agent this is the cheapest possible first call: about two hundred tokens tells you whether a slice of the web is worth searching at all before you spend anything searching it.

MCP: One URL, Five Tools, No Install

FreeSerp ships a hosted Streamable-HTTP MCP server at a single URL. There is nothing to install, nothing to run locally and — consistent with the rest of the product — no authorization step.

https://freeserp.ai/mcp

A plain GET on that URL returns the live tool catalogue as JSON: server name, transport, tool count and every tool with its description. The tool schemas are generated from the same field registry that powers the REST API and the documentation, so they physically cannot drift apart — add a field to the index and it appears in the docs, the REST filters and the MCP schema in the same deploy.

Wiring it into Claude Desktop, Claude Code or any other MCP client is one config block:

{
  "mcpServers": {
    "freeserp": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://freeserp.ai/mcp"]
    }
  }
}

Or talk JSON-RPC to it directly, with no client at all:

curl -s 'https://freeserp.ai/mcp' -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

curl -s 'https://freeserp.ai/mcp' -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
        "name":"freeserp_search",
        "arguments":{"q":"ai chatbot","sort":"dr","order":"desc","size":5}}}'

The Caveats, Printed on the Tin

FreeSerp documents its own weaknesses in the same page as its features, which is rarer than it should be. They matter if you are going to build on it.

There is one more, and it is structural: this is a discovery index. It is superb at what appeared on the web recently and what is it, and it is not the right tool for what does Google rank first for this commercial keyword. Those are different questions and it is honest about only answering one of them.

How the Index Gets Built

The search API is the small, visible end of a fairly large machine. Understanding the machine explains both the freshness and the caveats.

• 1 · Discovery Newly registered domains arrive daily from an NRD feed and from ICANN's CZDS zone files. This is the raw funnel — millions of names, most of which will never become a website.
• 2 · Liveness probing A probe runs every five minutes against the due queue, recording the first moment a domain answers with something real. That timestamp becomes went_live.
• 3 · Enrichment Live domains are fetched every ten minutes by a pool of workers: HTML, headers, resolved IP, web server, HTTP status, extracted text, page sizes.
• 4 · Real-site classification A classifier separates genuine content from parked pages, registrar holding screens, error walls and empty templates. This drives real_site, and it is why the default view is not full of domain-parking noise.
• 5 · LLM summarisation A summariser runs every fifteen minutes across the backlog, writing the factual ai_summary that every result carries.
• 6 · AI categorisation Every two hours a categoriser assigns the multi-label ai_categories taxonomy and the broad category bucket.
• 7 · Authority scoring A Domain Rating worker runs continuously over a private web-graph, scoring domains in batches of a few thousand at a time.
• 8 · Structural signals A parallel fleet detects contact forms and other page structures across six shards, and a synchroniser pushes every computed field back into the search cluster.

The pipeline block in the statistics response is a live window onto that conveyor: how many summaries are still pending, how many sites went live today, how many probes are due. When it reads zeros across the board, the machine has caught up with the web.

FreeSerp Against the Search-API Market

The site keeps a directory of comparisons at /search-apis, covering the paid SERP and scraping APIs (SerpApi, Serper, SearchApi.io, Scale SERP, ValueSERP, Zenserp, DataForSEO, Bright Data, Oxylabs, ScraperAPI, Scrapingdog, Apify, ZenRows), the search engines and AI-search products (Google Programmable Search, Bing Web Search, Brave, DuckDuckGo, Yandex, Baidu, Mojeek, Marginalia, Startpage, Ecosia, Kagi, You.com, Perplexity, Exa, Tavily, Phind, SearXNG, Presearch, Qwant, Swisscows, Yep, Common Crawl), and the self-hosted search infrastructure people end up building instead (Algolia, Meilisearch, Typesense, OpenSearch, Solr, Vespa).

The honest summary of where each fits:

The clean way to think about it: a SERP proxy tells you about rankings. FreeSerp tells you about the web itself. If your agent's question is who exists, what do they do, are they real, how big are they, when did they appear — that is FreeSerp's question.

Recipes Worth Stealing

Discover new AI startups in a niche

curl 'https://freeserp.ai/api.php?ai_startups=1&ai_categories=Code%20%26%20Dev%20Tools&from_date=2026-09-01&sort=went_live&order=desc'

Newest AI sites, most authoritative first

curl 'https://freeserp.ai/api.php?ai=1&sort=dr&order=desc&size=10'

Competitor and lookalike discovery

curl 'https://freeserp.ai/api.php?q=vector+database&ai_startups=1&dr_min=10&sort=dr&order=desc&size=25'

High-authority news sites that launched in the last fortnight

curl 'https://freeserp.ai/api.php?q=news&dr_min=30&from_date=2026-08-16&sort=went_live&order=desc'

Every site on a given stack, ranked by authority

curl 'https://freeserp.ai/api.php?ai_source=shopify&sort=dr&order=desc&size=25'

Is this domain real, parked, or dead?

curl 'https://freeserp.ai/api.php?q=somedomain.io&all=1&size=1'
# check results[0].real_site (1 = real content, 0 = parked/empty/error)
# and results[0].http_status

The Optional Courtesy: Tell FreeSerp Who You Are

No key means no way to contact anyone. FreeSerp's answer is four optional query parameters — agent, email, project, website (or the X-Agent header, or the same fields as MCP tool arguments). Nothing is validated, nothing is required, and none of it affects results.

curl 'https://freeserp.ai/api.php?q=ai&agent=MyAgent/1.0&[email protected]&project=Acme&website=https://acme.com'

What it buys you is narrow and honest: a warning before a breaking change, a question about what you are missing, and — if your traffic starts hurting the service — a request to slow down instead of a silent block. The values are stored privately alongside request counts, never published and never shared. Sending them once is enough.

Limits, Errors and Failure Modes

• No hard rate limit and no key. The ask is to be reasonable — a few requests per second, cache where you can, and identify yourself so a conversation is possible.
• Paging: size up to 100 per page; from + size up to 10,000. Beyond that, narrow the query.
• Caching: responses are edge-cached for roughly thirty seconds.
• HTTP 200 with "ok": true on success — results may legitimately be empty, so check total.
• HTTP 204 for CORS pre-flight.
• HTTP 502 for an upstream search error — retry with backoff.

Bad parameters never produce an error. Unknown filters are ignored, an invalid sort falls back to relevance, and an out-of-range size is clamped. A query always returns something, and the echoed filters object shows exactly what was applied — which is precisely the behaviour you want when an autonomous system is composing the query strings.

Who Actually Needs This

• Agent builders Web search as a tool call with no provisioning step, no key rotation and no billing integration. Wire the MCP URL in and the capability exists.
• RAG pipelines Every result already carries a clean, model-written summary and, on request, the full extracted page text — no HTML cleaning stage required.
• Market and competitive research Enumerate a niche by sub-niche and launch date, then sort by authority. This is a research database that happens to speak HTTP.
• VC and scouting workflows ai_startups=1 plus a date window is a daily feed of new AI companies, before any of them appear in a curated list.
• SEO and link work Domain Rating, live dates, tech stack and TLD, filterable together — plus the gambling operator/affiliate split for people who need it.
• Anyone tired of quotas The browser can call it directly. A shell script can call it. A cron job can call it. There is no account to break.

The Short Version

FreeSerp is a free web search and SERP API with no key, no signup, no account and no quota, backed by an independently built index of twenty-one million live sites. Every result arrives with an LLM-written summary, a Domain Rating, a tech-stack signal and a live date, and every field can be filtered and sorted — including with no search query at all. It speaks plain JSON over one GET request and it speaks MCP over one URL, and both surfaces are generated from the same registry so they never disagree.

It will not tell you what Google ranks. It will tell you what exists, what it is, whether it is real, and when it showed up — which, for most agents most of the time, is the question they were actually asking.

An AI agent cannot sign up for an account. Any API key just puts a human back in the loop.

FreeSerp, on why it is keyless

One request, no credentials: freeserp.ai · docs and MCP at freeserp.ai/docs.php.