The test in one section

On 2026-11-11 I registered Parallel's MCP server in one research profile of Codex (my luna-research profile). I used the free tier with no API key. Then I ran a small smoke test with two tools: web_search and web_fetch.

The whole test cost $0. It was a handful of calls, and I never hit a rate limit.

I have two findings.

  • web_fetch worked well. In a single call it read two URLs, an App Store page and that app's privacy policy. The values it extracted matched what I had read by hand.
  • web_search gave the right answer, but I still had to check the citation. I asked for the current stable Rust version and got the correct one. The source it cited was a third-party blog, not the official Rust page.

This was a smoke test, not a benchmark. I have no latency numbers and no systematic accuracy measurement. Read the rest with that in mind.

What changed in April 2026

There are two states to keep apart: what was announced in April, and what the product looks like now.

April 2026. On 2026-04-23, Parallel announced on its official blog that its Search MCP had become free, with no signup and no API key. At that time the server exposed two tools: web_search and web_fetch.

https://parallel.ai/blog/free-web-search-mcp

As of 2026-11-11. I checked the official MCP page on 2026-11-11. It lists four tools, and three of them are free. I'll cover them in the next section. The April announcement is only about the two original tools, so don't read it as describing today's lineup. The current page is the better reference.

https://parallel.ai/mcp

The current free tier in brief

The server's endpoint is https://mcp.parallel.ai/mcp. The official page lists four tools:

  • web_search: web search for agents.
  • web_fetch: reads pages, up to 20 URLs per call.
  • web_decisions: answers structured questions with citations, based on live web evidence.
  • web_research: deep research in a single call.

web_search, web_fetch and web_decisions work without an account or API key, with lower rate limits than the signed-in tier. web_research is the exception. It requires sign-in or an API key.

The page says that going over the free limit just gets you rate-limited and that "nothing is billed". That sentence is the main reason I was comfortable trying this in a real research profile.

One thing the page does not give is a number. It says the limits are "lower" and nothing more. I'm not going to guess a figure, and you shouldn't take one from me.

I only exercised two of the four tools. I did not try web_decisions or web_research, so I have nothing to report on them beyond what the official page says.

Connecting

If you already use MCP clients, there is little to say here. You register a remote server with the URL above, in whatever way your client does that. For me, that meant adding it to one research profile in Codex rather than to everything I use. I wanted a place where I could watch what it did without it appearing in every other session.

The one gotcha is the trailing slash. This works:

https://mcp.parallel.ai/mcp 

This returns a 404:

https://mcp.parallel.ai/mcp/ 

If you paste the URL from a source that adds a slash, or your editor autocompletes one, the server will look broken when it isn't. Check the URL first before debugging anything else.

Smoke test 1: search got the answer right, and cited a non-primary source

The query. I asked web_search for the current stable version of Rust.

The result. It returned 1.99.1, which was the correct version at the time of the test (2026-11-11).

The caveat. The source it cited was a third-party blog. It was not the official Rust page.

Those are two separate things, and it's easy to blur them. The answer was right. But a right answer doesn't make the cited source an authoritative one. A blog that reports the version correctly today can be wrong or stale tomorrow. If I had only looked at the answer and seen that it matched my expectation, I would have missed this entirely.

This isn't a complaint about Parallel in particular. I'd expect any search tool that returns an answer with a citation to raise the same question. The point is what I do with it. For anything that carries weight, such as a version I'm about to pin, a price I'm about to quote, or a policy I'm about to rely on, I still open the primary source myself. The search result tells me where to look and what to expect there. It doesn't replace checking it yourself.

For this particular query the stakes were low. I could verify it quickly, and the answer held up. I'd be more careful with facts where a wrong answer is expensive and the correct source is hard to find.

I'll also be clear about what this single query does and doesn't show. It shows one correct answer with a non-primary citation. It doesn't show how often this happens, and it doesn't show that the tool prefers third-party sources in general. One query can't tell me either of those.

Smoke test 2: fetch read an app page and a privacy policy in one call

This was the part I found more useful.

The setup. I had two URLs I wanted to read: the App Store page of an app called "issho", and that app's privacy policy. I wanted to know what the app costs and what the policy says about its data handling.

The call. I passed both URLs to web_fetch in a single call. Parallel documents support for up to 20 URLs per call; I tested two. Batching was the natural thing to do here. The two pages belong together, and I'd normally read them one after the other.

What it extracted. From the App Store page, it pulled the in-app purchase prices:

  • PLUS: ¥400
  • DETAIL: ¥200 per month, or ¥2,000 per year

From the privacy policy, it pulled the clauses about location data and about cloud sync.

How I checked. I compared the extraction against my own manual reading of the same pages, and they matched.

That matters because this is the kind of task where an agent's summary tends to be trusted without checking. Prices and privacy clauses are exactly the details where a small slip would be easy to miss. In this case I had a manual baseline to compare against, and the extraction held up.

The same limits apply as before. This is two pages, read once. It tells me the tool can do this job on these pages. It doesn't tell me how it behaves on pages with heavy scripting, long documents, or a full 20-URL batch. I didn't test any of those.

What I liked in practice is that the combination fits how I actually work. A store page and a policy are two documents that answer one question. Getting both in one call, with the relevant facts pulled out, saves a few steps and keeps the reading in one place.

Cost and limits

Cost. $0. I used the free tier with no API key, and nothing was billed. That matches the official page, which says exactly that.

Limits. I only have a qualitative picture, and it's thin:

  • The official page says the free limits are "lower" than the signed-in ones. It gives no number.
  • My test was a handful of calls, and I never hit a rate limit.

These calls were not rate-limited; the test did not establish where the cap is. If you plan to run a long agent loop, or several agents in parallel, against the free tier, you'll have to find the boundary yourself. Parallel says that excess calls on the free tier are rate-limited rather than billed — I did not encounter that behavior myself, so I'm reporting it as the company's statement, not as something I observed.

There's also a practical effect on how I'd use it. On Parallel's account, going over the limit costs time rather than money, so I'd treat the free tier as fine for exploratory work and for a profile like my research one. If I needed a guarantee of throughput, I'd look at the signed-in option, and I haven't evaluated that.

How to read the vendor's performance claims

Parallel's own blog makes performance claims. It says its search beats the standard search of major frontier models on public benchmarks, and that it tops Artificial Analysis's Search Index.

I'm reporting those as what they are: statements from the company's own blog. I haven't verified them independently, and my smoke test doesn't bear on them either way. This small smoke test cannot confirm or contradict a benchmark result, and I'm not going to pretend otherwise.

What I can say is narrower. For the two things I tried, the tool did what I asked, and the one thing I flagged, the citation, is something I'd flag for any search tool. If benchmark performance matters for your use case, read the benchmark sources and run your own queries on your own tasks. That's the only test that tells you something about your workload.

Takeaway

For a free tier with no signup, the barrier to trying this is close to zero, and on Parallel's account the downside of heavy use is rate limiting rather than a bill. In my small test, web_fetch extracted prices and policy clauses that matched my own reading, and web_search returned a correct answer. The one habit I'm keeping is checking the primary source for anything load-bearing, because a correct answer from a search tool doesn't mean the source behind it is the authoritative one. Whether the free limits suit your workload is something you'll only learn by running it.

Get the full smoke-test log ($5)

The paid document collects every query I sent, the full recorded results, where the answers hit and where they missed, and what the free tier cost — plus what is, and is not, known about its limits.

Get it on Gumroad

What's inside:

  • Every query I sent through web_search and web_fetch, in order
  • The full recorded results for each call, not just the excerpts quoted here
  • Where the answers hit and where they missed, including the citation issue in detail
  • Cost and limit findings: $0 billed, no rate limit encountered, and the numeric cap is not published

Originally published in Japanese on note. This English edition was translated and edited with AI assistance; the setup and measurements described are unchanged from the original work.