DEV Community: Hassann

Gemini API Free Tier in 2026: Limits, Models, and When You Get Billed

Hassann — Fri, 23 Oct 2026 10:17:12 +0000

Gemini API Free Tier in 2026: Limits, Models, and When You Get Billed

The Gemini API free tier still exists in October 2026, but it's narrower than it used to be. You can call Gemini 3.8 Flash, 3.6 Flash, 3.5 Flash-Lite, 3.1 Flash-Lite, Gemma 4 and several audio and embedding models for $0, with no billing account. Gemini 4 Argon, the image models and the video models are paid only. Google no longer prints per-model RPM and RPD numbers in its docs, and you're only billed after you link a billing account and prepay at least $5.

Try Apidog today

Every fact below comes from Google's pricing page, rate limits page, billing guide and Gemini API terms, read on October 22, 2026. Still need a key? Our guide to getting a free Gemini API key covers that step.

Is the Gemini API free?

Yes, partly. The Gemini API free tier gives every Google AI Studio project free input and output tokens on selected models, with no card and no billing account. Google describes it as "Limited access to certain models." In exchange, Google can use your prompts and responses to improve its products, and your rate limits are lower than on paid tiers.

Three rules shape it:

Free is per model. Each model's Free Tier column says either "Free of charge" or "Not available."
Limits are per project. They apply "per project, not per API key," so five keys in one project don't give you five times the quota.
Billing switches it off. A project linked to a billing account is on a paid tier, and every token is metered.

Which models are on the Gemini API free tier

Here's the Free Tier column for Standard requests on October 22, 2026, with paid prices per 1M tokens.

Model	Model ID	Free tier	Paid input / output
Gemini 4 Argon	`gemini-4-argon`	Not available	$2 / $10 through Nov 30, 2026, then $4 / $20
Gemini 3.8 Flash	`gemini-3.8-flash`	Free of charge	$0.75 / $3.75 through Dec 31, 2026, then $1.50 / $7.50
Gemini 3.6 Flash	`gemini-3.6-flash`	Free of charge	$0.75 / $3.75 through Dec 31, 2026
Gemini 3.5 Flash-Lite	`gemini-3.5-flash-lite`	Free of charge	$0.30 / $2.50
Gemini 3.1 Flash-Lite	`gemini-3.1-flash-lite`	Free of charge	$0.25 / $1.50
Gemini 3.1 Pro Preview	`gemini-3.1-pro-preview`	Not available	$2 / $12 (prompts up to 200K)
Gemma 4	`gemma-4-31b-it`, `gemma-4-26b-a4b-it`	Free of charge	No paid tier
Nano Banana 2.1 and Pro	`gemini-nano-banana-2.1`, `gemini-3-pro-image`	Not available	Paid only
Gemini Omni Flash (video)	`gemini-omni-1.1-flash`	Not available	Paid only

Audio fares better: Gemini 3.8 Live, 3.8 Flash TTS, 3.5 Transcribe and Gemini Embedding 2 all list free input and output.

Argon gets its own note on the pricing page: "Gemini 4 Argon is not available on the Free tier." Our Gemini 4 Argon pricing breakdown covers its paid rates and the December 1 price change.

Watch the 2.5 models too. The models page says Google is "limiting access to the 2.5 models to users who have actively used them in the past." Gemini 2.5 Pro and 2.5 Flash still show "Free of charge," but a new project may not reach them. Google points new work to 3.5 Flash-Lite or 3.8 Flash.

Gemini API free tier limits: what Google publishes now

Google publishes the rules, not the numbers. The rate limits page no longer carries a per-model RPM, TPM and RPD table. It sends you to the rate-limit view in Google AI Studio, which shows the active limits for your own project.

What the page does state:

Three dimensions: requests per minute (RPM), input tokens per minute (TPM) and requests per day (RPD). Some models add tokens per day or images per minute.
Any one limit trips you: "If your RPM limit is 20, making 21 requests within a minute will result in an error, even if you haven't exceeded your TPM or other limits."
Daily reset: RPD quotas reset at midnight Pacific time.
Previews are tighter: "Rate limits are more restricted for experimental and preview models."
No guarantee: "Specified rate limits are not guaranteed and actual capacity may vary."

Free models also skip some features:

Feature	Free tier	Paid tier
Grounding with Google Search	Not available (some models note it "can be tested in Google AI Studio")	5,000 requests/month free across Gemini 3+ models, then $14 per 1,000
Batch API and Flex	Not available	Half the Standard price on 3.8 Flash
Context caching	Free on 3.8 Flash and 3.6 Flash; not on 3.5 or 3.1 Flash-Lite	Metered, plus hourly storage

Check your real numbers in AI Studio before you design a retry policy. When you hit a ceiling, the API answers 429 RESOURCE_EXHAUSTED; our guide to using Gemini 3.8 Flash for free shows backoff for the Flash models.

What the free tier costs you: your data

The free tier is free in dollars, not in data. The terms treat "unpaid quota on Gemini API" as an Unpaid Service, and for those Google "uses the content you submit to the Services and any generated responses to provide, improve, and develop Google products." They add: "human reviewers may read, annotate, and process your API input and output."

So keep customer records, secrets and anything under NDA off a free-tier key.

Two regional rules apply in the European Economic Area, Switzerland and the United Kingdom:

The paid-service data terms cover everything there, "including Google AI Studio and unpaid quota in the Gemini API."
You "may use only Paid Services when making API Clients available to users" in those regions. A free key is fine for your own testing, not for a product serving those users.

When you get billed on the Gemini API

You're billed only after you upgrade a project. A free-tier project has no billing account, so nothing on it turns into a charge. The billing guide lays out the path:

Set up billing in AI Studio. On the Projects or API keys page, click "Set up billing" on the project you want to upgrade.
Prepay at least $5. New users default to Prepay: you buy credits ($5 minimum, $5,000 maximum) and usage is deducted in near real time. Some accounts are offered Postpay instead.
Land on Tier 1. An active billing account puts you on Tier 1, typically at once, with a $250 monthly cap and a $10 spend limit per rolling 10 minutes.
Climb by spend. Tier 2 needs $100 paid plus 3 days since your first payment ($2,000 cap). Tier 3 needs $1,000 plus 30 days ($20,000 to $100,000+ cap). Spend on any Google Cloud service counts.

What catches people out:

The $300 Google Cloud credit doesn't cover Gemini. "Starting March 2026, Gemini API usage costs are specifically excluded from the $300 Google Cloud Free Trial program."
Credits expire. Unused prepay credits expire after 12 months and aren't refundable, except when you switch to Postpay.
At $0, everything stops. "All API keys in all projects linked to that billing account will stop working simultaneously," with HTTP 402 until you top up.
Overages slip through. Billing lags about 10 minutes, so batch jobs and agents "may continue to consume credits beyond your balance."
Failed requests are free but count. A 400 or 500 isn't charged, "however, the request will still count against your quota."

A clean setup is two projects: a free one for experiments and a paid one with a project spend cap for real traffic.

Make your first free Gemini API call

With a key from a free-tier project, this REST call to Gemini 3.8 Flash costs $0:

export GEMINI_API_KEY="your-free-tier-key"

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
  -H "x-goog-[REDACTED CREDENTIAL] \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{"contents": [{"parts": [{"text": "Explain HTTP 429 in one sentence."}]}]}'

A 200 with text in candidates[0].content.parts[0].text means the free tier served you. Don't expect the same key to answer for gemini-4-argon: Argon needs a paid project. Keep the key in an environment variable, never in a commit.

Let your coding agent test it with Apidog CLI

Skip checking model IDs and limits by hand. With Apidog CLI, Claude Code, Codex, Cursor or OpenCode can write a test case for the Gemini endpoint, run it against your free key and report any 429.

Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent one [REDACTED PROMPT]
In Apidog project , create an environment "gemini-free" with base URL
https://generativelanguage.googleapis.com. Add a test case for
POST /v1beta/models/gemini-3.8-flash:generateContent with header
x-goog-[REDACTED CREDENTIAL] that asserts status 200 and non-empty
candidates[0].content.parts[0].text. Run it 5 times, 1 second apart, and
tell me if any run returned 429.


The agent reads the payload schema, validates its JSON, then creates and runs the case:

bash
apidog environment create gemini-free --project --base-url https://generativelanguage.googleapis.com
apidog cli-schema get test-case-create
apidog test-case category --project
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project --file case.json
apidog run --test-case --project -e \
--env-var "GEMINI_API_KEY=$GEMINI_API_KEY" -n 5 --delay-request 1000 -r cli,json




Keep `-n` small: every iteration counts against your RPM and RPD. The same `apidog run` line with `-r junit` drops into CI; our walkthrough of [Apidog CLI in Claude Code](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) shows the full loop. Apidog's Free plan covers up to 4 users, so a small team can share the project.

## FAQ

**Is the Gemini API free tier free forever?** Google promises no end date. The pricing page lists "Free of charge" per model today, and not every model gets one: Argon and the image models are paid only. Re-check the page before you plan around it.

**Does the Gemini API free tier need a credit card?** No. Its only qualification is "Active project or free trial." You add a card when you set up billing and prepay at least $5.

**What are the Gemini API free tier limits per model?** Google stopped printing them in the docs. Your active RPM, TPM and RPD per model are on your project's rate-limit page in AI Studio, and RPD resets at midnight Pacific time.

**Can I use Gemini 4 Argon for free through the API?** No. "Gemini 4 Argon is not available on the Free tier." Our [Gemini 4 Argon free access guide](http://apidog.com/blog/gemini-4-argon-free?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation) covers the routes outside the API.

**Will the $300 Google Cloud credit pay for Gemini API calls?** Not for accounts opened after March 2, 2026. Gemini API usage is excluded from the $300 free trial, though the credit still works on other Google Cloud products.

**How do I go back to the free tier after upgrading?** Unlink the project from its billing account. It returns to the free tier and its free-tier model set.

PHP2Shell: The PHP Bug That Lets Anyone Run Code on Your Server (Patch Now)

Hassann — Fri, 23 Oct 2026 07:19:30 +0000

PHP2Shell: The PHP Bug That Lets Anyone Run Code on Your Server (Patch Now)

On October 21, 2026, the PHP project shipped emergency releases for two critical bugs that let an unauthenticated attacker run code on a web server. The pair is tracked as CVE-2026-109618 and CVE-2026-109619 and goes by the name PHP2Shell. Both score 9.2 on CVSS v4.0, both hit every PHP setup that serves HTTP, and Amazon's honeypots logged exploitation attempts on October 17 — four days before the patch existed.

Try Apidog today

PHP runs on 69.3% of websites whose server-side language is known (W3Techs). If you run a PHP API, a Laravel or Symfony backend, a WordPress site, or a container image with PHP baked in, this one is yours.

This guide covers what the bugs do, which versions are affected, how to check your servers, what the mitigations really buy you, and how to prove your API still works after you patch.

TL;DR

Question	Answer
What is it?	Two memory-safety bugs in PHP's request handling, chained into remote code execution
CVEs	CVE-2026-109618 (out-of-memory corruption), CVE-2026-109619 (stale state, use-after-free)
Severity	CVSS v4.0 9.2 each (early leaked IDs said 10.0; PHP says that was wrong)
Auth needed?	No
Affected	Every SAPI that serves HTTP: PHP-FPM, Apache mod_php, php-cgi, FrankenPHP, LiteSpeed
Fixed versions	8.5.12, 8.4.27, 8.3.36, 8.2.35
PHP 8.1 and older	No official release; minimal source backports for 7.4, 8.0, 8.1; 5.4 to 7.3 get nothing
Exploited?	Attempts seen from October 17 (Amazon), early attacks reported by Cloudflare
Fix	Upgrade, restart every worker. Workarounds reduce risk but don't close it

What PHP2Shell actually is

Both bugs share one root cause: PHP can leave its memory in a broken state when a request ends abnormally, and the cleanup code then trusts that broken state.

CVE-2026-109618: out-of-memory corruption during request startup. When PHP parses form data into $_POST, the Zend engine's hash table code bumps its entry counter before it allocates the new key. Datadog's analysis traces it to _zend_hash_str_add_or_update_i() in zend_hash.c. If that allocation blows past memory_limit, PHP throws a fatal error and abandons the insert — but the counter now includes a bucket that was never set up. At shutdown, PHP destroys $_POST and treats every counted bucket as real.

The part that should worry API teams: this happens while PHP is still parsing the request body, before a single line of your code runs. Your auth middleware, your rate limiter and your input validation never see the request. Datadog reproduced it with a plain application/x-www-form-urlencoded body, not a file upload.

CVE-2026-109619: stale global state across requests. PHP keeps some worker-wide state that points at per-request memory. If a fatal error interrupts the reset of that state, or a late shutdown diagnostic recreates it after cleanup, the next request on the same worker reads freed memory. PHP confirmed two paths:

Fatal-error backtraces (PHP 8.5 only): a configuration diagnostic in a later request reads leftover backtrace state. Command execution confirmed on mod_php.
Upload processing: after a fatal error, session upload progress can leave state behind for a later upload. Upload progress is on by default and runs even if your app never calls session_start(). Command execution confirmed on mod_php and PHP-FPM.

The PHP security team rates mod_php as the highest risk, since the demonstrated exploit fires from one unauthenticated request before any application code loads.

Who found it (and why AI is in the headlines)

The bugs date back to code introduced in PHP 5.4.0, so they sat in the codebase for over a decade. The PHP Foundation credited Calif, OpenAI and Wiz.

Reporting from Decrypt and The Next Web says Calif researcher Ryan Austin found the flaws in August during a source audit assisted by OpenAI's GPT-5.6 Sol. OpenAI says its own team found a fuller version in September as part of its "Patch the Planet" work. Wiz says it found both bugs on its own using Gemini 4 Argon, Wiz Atlas and GPT-5.6 Sol. The credit is disputed; the takeaway isn't. AI-assisted audits are now finding decade-old memory bugs in core infrastructure — and attackers have the same models.

Timeline: why the patch came a day early

Date (2026)	What happened
August to September	Calif, OpenAI and Wiz report the bugs privately
Oct 17	Amazon's MadPot honeypot records an exploitation attempt
Oct 20	CVE IDs leak on Hacker News and social media; PHP posts an advance notice; CERT-EU issues advisory 2026-018
Oct 21, 14:00 UTC	PHP ships fixes, moved up from Oct 22 after the leak; CISA publishes an alert; Cloudflare reports early attacks
Oct 22	Neither CVE is in CISA's KEV catalog yet

Amazon advises investigating from October 17 (Tenable's FAQ tracks the full timeline), not the disclosure date. At release, the PHP team said it inspected the proof-of-concept code that appeared after the leak and found no working exploit. watchTowr has since said it reproduced both bugs. Treat any "PoC" repo you find as suspect: unverified exploit code often ships malware.

Are you affected? Check in five minutes

1. Check the runtime that serves traffic, not your laptop. The CLI binary can differ from the FPM or Apache module in version and config.

# On the server or inside the running container
php -v
php-fpm -v
# Apache mod_php: check the loaded module version
apachectl -M 2>/dev/null | grep -i php

Or expose it once from a protected route and remove it after:

<?php echo PHP_VERSION, ' ', PHP_SAPI;

2. Compare against the fixed versions.

Branch	Vulnerable	Fixed in
8.5	< 8.5.12	8.5.12
8.4	< 8.4.27	8.4.27
8.3	< 8.3.36	8.3.36
8.2	< 8.2.35	8.2.35
7.4 to 8.1	All	Source backports only, or vendor LTS
5.4 to 7.3	All	No fix

Debian, Ubuntu, Red Hat and other distros often backport fixes without changing the upstream version string. If php -v shows an older number, read your distro's advisory before panicking.

3. Inventory the hidden PHP. Containers built FROM php:8.3-fpm months ago, vendor appliances, self-compiled builds, admin panels on forgotten subdomains. Cisco has already opened an advisory to check its own product line. Shodan counts over 1.9 million internet-facing PHP hosts; one researcher estimates 1.3 million or more may be vulnerable.

How to patch

# Debian / Ubuntu (Ondřej Surý PPA or distro packages)
sudo apt update && sudo apt install --only-upgrade 'php8.*'

# RHEL / Rocky / Alma with Remi
sudo dnf upgrade 'php*'

# Official Docker image: rebuild on a fixed tag
docker pull php:8.4.27-fpm
docker build --pull -t my-api:patched .

Then do the step most teams forget: restart or replace every PHP worker. A running FPM pool keeps the old binary in memory. Restart php-fpm, reload Apache, and roll every container. CVE-2026-109619 is about state that lives across requests inside a worker, so an unrestarted worker is still vulnerable.

On 8.1 or older, you have three options: a vendor LTS package, building from PHP's source backport, or upgrading to 8.2+. CISA recommends taking unpatchable PHP systems offline, and the UK NCSC and FBI said the same.

Mitigations if you can't patch today

These buy time. Gina Peter Banyard of the PHP core team told BleepingComputer no mitigation fully blocks the attacks.

For CVE-2026-109618:

Set memory_limit=-1 where apps can't override it (php_admin_value in the FPM pool or Apache config). This blocks the known path, but not every way an allocation can fail.
Lower post_max_size (8M with no uploads, 32M with uploads).
Cap request body size at the reverse proxy (client_max_body_size in nginx), and set container or cgroup memory limits as an availability boundary.
Don't use RLIMIT_AS or RLIMIT_DATA process limits. They can cause the very allocation failures the exploit needs.

For CVE-2026-109619:

Set session.upload_progress.enabled=0 in config that loads before request parsing.
On PHP 8.5, also set fatal_error_backtraces=0.
Hiding errors with display_errors=0 or @ does nothing. The stale state still exists.

At the edge: Cloudflare deployed WAF rules for known vectors on every plan, including free. Its CTO called them temporary.

After any php.ini change, restart every worker or it doesn't take effect.

Signs you were already hit

Datadog's detection guidance boils down to four signals:

Log line: PHP Fatal error: Allowed memory size of ... bytes exhausted with Unknown on line 0. That means PHP died during request startup, before any script ran.
Apache crashes: AH00052: child pid ... exit signal Segmentation fault (11), a likely failed exploit guess.
Odd form posts: a field name several megabytes long, or binary and null bytes in a field with an empty name.
The strong one: a web worker (php-fpm, apache2, httpd) spawning a shell.

Don't trust status codes. Datadog's refined exploit returned HTTP 200 and the worker kept running. Search logs back to October 17.

Prove your API still works after the patch: let your agent run it

Patching PHP in production under pressure is how you find out a minor version bump changed something. Before and after you roll the fix, run your API test suite against staging, and let your coding agent do it with Apidog CLI.

Setup (once):

npm install -g apidog-cli
apidog auth login --with-token <your-access-token>
apidog test-suite list --project <projectId>

One prompt to Claude Code, Codex or Cursor:

We just upgraded PHP to 8.4.27 on staging for PHP2Shell. Use the Apidog CLI to run our regression test suite against the staging environment, write HTML and JUnit reports, and summarize any failing endpoints. Then confirm a POST with a body above our nginx client_max_body_size gets rejected with 413 at the proxy instead of reaching PHP.

What the agent runs:

apidog test-suite run <testSuiteId> --project <projectId> -e <stagingEnvId>

apidog run --test-suite <testSuiteId> --project <projectId> -e <stagingEnvId> \
  -r cli,html,junit --out-dir ./php2shell-reports --upload-report

-r picks the reporters, --out-dir sets where reports land, and --upload-report pushes a summary you can open in the Apidog app. Add --notification-failed-event <targetId> to ping your team only when something breaks. Drop the same apidog run line into CI so every rebuilt PHP image gets tested before it ships. The Claude Code setup guide and the CI/CD pipeline walkthrough cover both in detail.

Run the suite once on the old version to get a baseline, once after the upgrade, and diff. If a test you never expected to fail does, you'll know before your users do. Download Apidog to build and manage the suites the CLI runs.

FAQ

Is PHP2Shell being exploited? Amazon saw attempts from October 17 and says it's now broadly exploited; Cloudflare and watchTowr report attacks too. CISA hadn't confirmed exploitation as of October 22.

Does my framework protect me? No. CVE-2026-109618 fires while PHP parses the body, before Laravel, Symfony or WordPress loads.

I'm on shared hosting. What do I do? Check your host's status page. SiteGround and others say they've patched. If yours hasn't said anything, ask.

Is session.upload_progress.enabled=0 enough? No. It covers one path of one CVE. Patch.

Do I need to rotate secrets? CVE-2026-109619 allows memory disclosure. If logs show signs of compromise since October 17, rotate database passwords, API keys and session secrets the PHP process could read.

The bottom line

Upgrade to 8.5.12, 8.4.27, 8.3.36 or 8.2.35. Restart every worker. Find the PHP you forgot about. Check logs back to October 17. Then run your API tests so the fix doesn't become the next outage. If your PHP is on 8.1 or older, this is the week to finally move off it.

Top 9 Free Web Search API

Hassann — Fri, 23 Oct 2026 07:18:47 +0000

If you need a free web search API for an AI agent, start with Tavily (1,000 free credits a month, no card) or Exa ($10 of free credit every month, no payment method). Brave gives $5 of monthly credit, Serper gives 2,500 free queries on signup, and SearXNG is $0 forever if you host it yourself. Every quota below was checked on each provider's official pricing page on October 22, 2026.

Try Apidog today

Agents fire many searches per task, so a free tier that looks generous for a human can run dry in an afternoon. This guide compares nine free routes by what matters for agents: quota, rate limit, card requirement and response shape.

What is a free web search API?

A free web search API is an HTTP endpoint that takes a query and returns ranked web results (titles, URLs, snippets, sometimes full page text) at no cost up to a quota. Most free tiers today are monthly credit grants rather than unlimited access. AI-focused APIs return LLM-ready text; SERP APIs return Google-style result pages as JSON.

A SERP API (Serper, SerpApi) mirrors what a person sees on Google. An AI search API (Tavily, Exa, Linkup) trims page content for an agent's context window, so you skip a separate scraping step.

Free web search APIs compared

API	Free quota	Resets	Card needed	Rate limit on free	Best for
Tavily	1,000 credits (1 per basic search)	Monthly	No	100 RPM (dev key)	Agent grounding, LangChain-style tools
Exa	$10 credit (up to 2,500 Lite searches)	1st of each month	No	Not published	Semantic, neural search
Brave Search API	$5 credit (about 1,000 requests)	Monthly	Yes, for abuse checks	50 requests/second	Independent index, high throughput
Serper	2,500 queries	One-time signup grant	No	Not stated for free	Cheap Google results
SerpApi	250 searches	Monthly	Not stated	50 searches/hour	Many engines, structured SERPs
Firecrawl	1,000 credits (500 searches)	Monthly	No	2 concurrent requests	Search plus scrape in one call
Jina Search	10M tokens per new key	One-time	No	100 RPM with free key	Top 5 results as clean text
Linkup	$20 credit (up to 4,000 queries)	Topped up monthly	No (professional email)	Not stated	Agent search with sourced answers
SearXNG	Unlimited, self-hosted	n/a	No	Your own server	Privacy, zero vendor quota

"Not stated" means the official page didn't say on October 22, 2026. Treat it as unknown, not unlimited.

The 9 free search APIs, one by one

1. Tavily: 1,000 free credits a month

Tavily's free Researcher plan gives 1,000 API credits a month with no credit card. A basic search costs 1 credit and an advanced search costs 2, so you get 1,000 basic or 500 advanced searches. Development keys allow 100 requests per minute. It's one POST https://api.tavily.com/search call with a Bearer [REDACTED]: the least friction for a first agent integration.

2. Exa: $10 of credit, refilled monthly

Exa's free tier credits $10 the day you sign up and resets the balance to $10 on the first of every month. No payment method is required. At $4 per 1,000 Lite or Instant searches, that's up to 2,500 searches; at $7 per 1,000 for Auto or Fast, it's about 1,400. Its neural search is strong at "find pages like this" queries where keywords fail. We covered its agent tooling in the Exa MCP server guide.

3. Brave Search API: $5 of monthly credit

Brave moved to prepaid credits. The Search plan costs $5 per 1,000 requests and includes $5 of free credit every month, applied automatically, which works out to roughly 1,000 free requests. Capacity is 50 requests per second. Brave asks for a credit card at signup and says why on its pricing page: "To prevent abuse." Results come from Brave's own independent index. See Brave Search API with MCP for the agent setup.

4. Serper: 2,500 free Google queries

Serper's homepage offers 2,500 free queries with no credit card required and returns Google results as JSON in 1 to 2 seconds. It's a signup grant, not a monthly refill, so it suits prototyping more than production.

5. SerpApi: 250 searches a month

SerpApi's free plan includes 250 searches per month with a throughput of 50 searches per hour. That's small for an agent, but each result page comes back parsed into detailed structured fields. Use it when you need one engine-specific SERP feature, not bulk grounding.

6. Firecrawl: search and scrape together

Firecrawl's Free Plan gives 1,000 credits a month, "no cost, no card", which the pricing page equates to 500 searches or 1,000 scraped pages, with 2 concurrent requests. The advantage is that search and scraping share one API and one credit pool, so your agent can find pages and pull their full content without a second vendor.

7. Jina Search (s.jina.ai): 10M free tokens per key

Prepend https://s.jina.ai/?q= to a query and Jina returns the top five results with their content as clean, LLM-friendly text. Every new API key comes with 10M free tokens, and each search costs a fixed amount starting at 10,000 tokens, so the free grant covers up to about 1,000 searches. A free key gets 100 requests per minute. In our test on October 22, an anonymous call without a key returned 401 AuthenticationRequiredError ("blocked from performing anonymous queries due to bad IP reputation"), so plan on using a key.

8. Linkup: $20 monthly credit for work emails

Linkup credits $20 when you sign up with a professional email address and tops eligible accounts back up to $20 each month. Its pricing page frames that as "Run 4,000 queries for free." Failed requests cost nothing.

9. SearXNG: self-hosted, no quota

SearXNG is an open-source metasearch engine you run on your own server or laptop. The software is free, and there's no vendor quota. Two gotchas: JSON output must be enabled under the search: section of settings.yml (requesting an unset format returns 403 Forbidden), and many public instances disable JSON, so don't build an agent on someone else's instance.

Which free tier is gone, and which isn't web search

Google's Custom Search JSON API still lists 100 free queries per day, but Google's overview page now says it is "closed to new customers", and existing customers "have until January 1, 2027 to transition to an alternative solution." If an old tutorial tells you to create a Programmable Search Engine key, skip it.

The DuckDuckGo Instant Answer API also shows up in these searches, but it returns topic summaries, not ranked web results, so it can't be an agent's main search tool.

If you run models locally, Ollama also offers a web search API that needs a free Ollama account; we walked through it in Ollama's web search API with MCP. Its docs don't publish a free search quota, so it isn't in the table.

How to choose a free search API for your agent

Pick by the shape of your workload:

Prototype an agent this week: Tavily or Exa. Both refill monthly with no card.
High query rate: Brave, at 50 requests per second, if you're fine adding a card.
You need Google's exact results: Serper for volume, SerpApi for parsed SERP features.
You want page content, not snippets: Firecrawl or Jina.
Zero vendor dependency: SearXNG on your own server.

You can also stack them: call one provider first and fall back to a second on a 429 or an empty result.

Let your coding agent test the search API with Apidog CLI

Free quotas fail quietly: a balance hits zero or a response shape changes, and your agent answers from stale memory without an error. A daily contract test catches that. Let your coding agent write and run it with Apidog CLI.

Set up the CLI and the agent skill once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give Claude Code, Codex or Cursor one prompt:

In Apidog project <projectId>, create an environment "tavily-free" with base URL
https://api.tavily.com. Create a test case for POST /search with body
{"query": "{{q}}", "search_depth": "basic", "max_results": 5} and header
Authorization: Bearer {{TAVILY_API_KEY}}. Assert status 200, a non-empty
results array, every result has a url, and response time under 3000 ms.
Add a second case with no Authorization header that asserts 401.
Run both and summarize any failures.

The agent reads the payload schema instead of guessing it, validates the file, writes the case and runs it:

apidog environment create tavily-free --project <projectId> --base-url https://api.tavily.com
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case category --project <projectId>
apidog test-case create --project <projectId> --file case.json
apidog run --test-case <caseId> --project <projectId> -e <envId> \
  --env-var "TAVILY_API_KEY=tvly-xxxx" --env-var "q=apidog cli" -r cli,json

Each run spends 1 Tavily credit, so a daily check costs about 30 of your 1,000. To test another provider, ask the agent to swap the base URL and auth header (Brave uses X-Subscription-Token, Exa uses x-api-key) and keep the same assertions. Put the same apidog run line with -r junit into your pipeline, as shown in the Apidog CLI CI/CD guide, and add --upload-report if you want to view the run in the Apidog app. For agent-specific setup, see Apidog CLI in Claude Code. Apidog's Free plan covers up to 4 users.

Make a free quota last longer

Cache by query. Agents repeat searches inside one task, especially on retries.
Default to the cheap mode. Tavily basic costs half of advanced; Exa Lite is $4 per 1,000 against $7 for Auto.
Ask for 5 results, not 20. Agents rarely read past the top few.
Fetch full pages selectively, only for the 1 or 2 URLs the agent picks.

FAQ

Is there a completely free web search API with no limits? Not as a hosted service. The closest is SearXNG on your own server, where the limit is your hardware.

Is the Brave Search API still free? Brave includes $5 of free credit every month on its Search plan, about 1,000 requests at $5 per 1,000. It asks for a credit card at signup to prevent abuse, and charges only for credits you buy.

Which free search API is best for AI agents? Tavily or Exa for most agents: LLM-ready content, monthly refills, no card.

Can I still get a free Google Custom Search API key? No. Google's Custom Search JSON API is closed to new customers, and existing customers have until January 1, 2027 to move. Serper and SerpApi are the free routes to Google results.

Do free search API credits roll over? Don't count on it. Exa resets your balance to $10 on the first of each month rather than adding to it, and Tavily, Brave and Firecrawl describe a monthly allowance without promising rollover. Serper's and Jina's free grants are one-time.

How do I know my agent's search API is still working? Run a scheduled contract test like the Apidog CLI one above.

For more no-cost building blocks, see our list of free APIs and how to give a free LLM web search.

Top 10 Free News APIs for Developers

Hassann — Fri, 23 Oct 2026 04:09:58 +0000

The best free news API for most side projects is NewsData.io (200 credits a day, no card) or GNews (100 requests a day, no card). If you need full article text, the Guardian Open Platform gives 500 free calls a day. If you want zero signup, GDELT, Hacker News and Spaceflight News answer with no key at all. Every quota below was checked on the provider's official page on October 22, 2026, and every keyless API was called live the same day.

Try Apidog today

Free news APIs differ on four things that matter more than the headline quota: freshness, search history, commercial use and card requirement. This guide compares 10 of them on exactly those points.

What is a free news API?

A free news API is an HTTP endpoint that returns news articles (headline, source, URL, publish time, often a snippet or image) as JSON, at no cost up to a daily or monthly quota. Aggregators pull from thousands of outlets; publisher APIs like the Guardian and NYT return their own archive, often with full text.

Most free tiers trade freshness for price. A 12 or 24 hour delay is common, and so is a "non-commercial only" clause. That's fine for a prototype or a personal dashboard, not for a paid product.

Free news APIs compared

API	Free quota	Delay / history	Card needed	Commercial use on free	Key needed
NewsData.io	200 credits/day (1-10 articles each)	12 h delay, past 48 h	No	Not stated	Yes
GNews	100 requests/day, 10 articles each	12 h delay, 30 days	No	No	Yes
NewsAPI.org	100 requests/day	24 h delay, 1 month	No card field on signup	No (dev and test only)	Yes
Currents API	250 requests/day	Up to 30 days	Not stated	Redistribution needs separate terms	Yes
World News API	50 points/day, 1 request/second	Not stated	No	Not stated, attribution link required	Yes
Guardian Open Platform	500 calls/day, 1 call/second	Full archive, 1.9M+ items	No card field on signup	No	Yes
NYT Developer APIs	500 requests/day, 5/minute per API	Archive varies by API	Not stated	No	Yes
GDELT DOC 2.0	1 request every 5 seconds	Global, many languages	No	Not stated	No
Hacker News API	No rate limit currently	Real time	No	Not stated	No
Spaceflight News API	Not published	Real time, 36,000+ articles	No	Not stated	No

"Not stated" means the official page didn't say on October 22, 2026. Treat it as unknown, not as permission.

How these were tested

Every number comes from the provider's own pricing page, FAQ or docs, read on October 22, 2026. The three keyless APIs (GDELT, Hacker News, Spaceflight News) got real requests and returned live October 2026 articles. The seven keyed endpoints were called without a key to confirm they exist and return a clean auth error (NewsAPI: 401 apiKeyMissing). No authenticated calls were made, so per-request result counts come from the pricing pages.

The 10 free news APIs, one by one

1. NewsData.io: the largest daily free quota

NewsData.io gives 200 API credits a day, and one credit returns between 1 and 10 articles. Its FAQ says plainly that no credit or debit card is needed for the free plan. The trade-off is freshness: free data is delayed by 12 hours and covers only the past 48 hours.

2. GNews: simple, and no payment details ever

GNews gives 100 requests a day with up to 10 articles per request, so roughly 1,000 articles a day. The pricing page says the free plan "never asks for payment details." You get 30 days of history and a 12 hour delay. It's non-commercial only, and CORS is enabled for localhost only.

curl "https://gnews.io/api/v4/top-headlines?lang=en&max=10&[REDACTED CREDENTIAL]"

3. NewsAPI.org: the one tutorials use

NewsAPI is the name most tutorials reach for. The free Developer plan gives 100 requests a day, articles arrive with a 24 hour delay and search reaches back one month. Its FAQ says the plan "cannot be used in a staging or production environment." The signup form asks for name, email and password only.

curl -H "X-[REDACTED CREDENTIAL] "https://newsapi.org/v2/everything?q=openapi&language=en"

4. Currents API: 250 requests a day

Currents gives 250 free requests a day for "evaluation, prototypes, and small apps," with recent history up to 30 days. Redistribution and republication need separate terms, so don't build a public news site on the free key. Whether signup asks for a card isn't stated on the pricing page.

5. World News API: small quota, strict pacing

World News API's free plan gives 50 points a day, 1 request per second and 1 concurrent request. No payment information is needed. One extra condition: free users must link to worldnewsapi.com from their site or app.

6. Guardian Open Platform: full article text for free

The Guardian's Developer key is the best free route if you need the article body, not just a snippet. It allows up to 500 calls a day at 1 call per second, with access to article text across more than 1.9 million pieces of content.

It's for non-commercial use, such as dissertations, hackathons and nonprofit apps. The old shared [REDACTED CREDENTIAL] no longer works (it returnedUnauthorized` on October 22, 2026), so register a key.

bash curl "https://content.guardianapis.com/search?q=api&show-fields=bodyText&[REDACTED CREDENTIAL]_KEY"

7. New York Times Developer APIs: archive depth

The NYT portal offers several APIs (Top Stories, Article Search, Archive). Its FAQ sets two limits per API: 500 requests a day and 5 requests a minute, and it tells you to sleep 12 seconds between calls. Use is non-commercial only.

8. GDELT DOC 2.0: global coverage, no key

GDELT monitors news in many languages and exposes a full-text search API with no signup. Fire two requests too fast and you get a plain-text reply: "Please limit requests to one every 5 seconds." Add sourcelang:english to the query if you only want English sources.

bash curl "https://api.gdeltproject.org/api/v2/doc/doc?query=%22open%20source%22%20sourcelang:english&mode=artlist&maxrecords=10&format=json&timespan=1d"

Throttled responses are plain text, not JSON, so check the body before you parse it.

9. Hacker News API: tech news, real time

The official Hacker News API runs on Firebase, needs no key and, per its README, has no rate limit at the moment. /v0/topstories.json returns up to 500 story IDs; you then fetch each one with /v0/item/<id>.json.

That two-step pattern means 30 headlines cost 31 calls, so cache item responses.

bash curl "https://hacker-news.firebaseio.com/v0/topstories.json" curl "https://hacker-news.firebaseio.com/v0/item/8863.json"

10. Spaceflight News API: a niche feed with no limits

If your app is about launches, rockets or space missions, the Spaceflight News API is free, keyless and focused. Its v4 /articles/ endpoint reported 36,589 articles on October 22, 2026, and a search=launch query returned a NASA story published the day before.

No rate limit is published, and the project runs on donations, so cache what you fetch.

Free news APIs that need a second look

TheNewsAPI also has a $0 plan: 100 requests a day, but only 3 articles per request, so it's the smallest result size here. Whether signup asks for a card isn't stated.

Mediastack's free plan gives 100 calls a month, with delayed data, non-commercial only. That's about 3 calls a day.

Google News has no official API, so it's left out.

How to choose a free news API

Need full article text? Use the Guardian (500/day) or NYT (500/day). Aggregators mostly return snippets.
Need many sources and no card? Use NewsData.io (200 credits/day) or GNews (100 requests, about 1,000 articles/day).
Need zero signup? Use GDELT for global news, Hacker News for tech and Spaceflight News for space.
Shipping a paid product? None of the keyed free tiers here clearly allow it. NewsAPI, GNews, Guardian, NYT and Mediastack say non-commercial or dev-only outright. Budget for a paid plan or a commercial key.
Need breaking news? Free tiers delay 12 to 24 hours on NewsData.io, GNews and NewsAPI. The keyless feeds and publisher APIs are closer to real time.

If you're building a broader project, the free APIs list and public APIs for testing cover more categories, and free movie APIs and the free crypto price API guide follow the same verified-quota format.

Let your coding agent test the news API with Apidog CLI

A news integration breaks quietly: a key expires or a field you parse goes missing. Your coding agent (Claude Code, Codex, Cursor) can write a test with Apidog CLI and run it on a schedule or in CI.

Set it up once:

bash npm install -g apidog-cli@latest apidog auth login --with-token <YOUR_APIDOG_TOKEN> apidog skill install

Shortcut: tell your agent "Read https://apidog.com/apidog-cli-installation-guide.md and set up Apidog CLI." The guide is written for agents.

Then give your agent one [REDACTED PROMPT]
In Apidog project , create an environment for GNews with base URL
https://gnews.io/api/v4. Create a test case for GET /top-headlines?lang=en&max=10
that asserts status 200, that "articles" is a non-empty array, and that every
article has title, url and publishedAt. Pass the key as an environment variable,
run it, and summarize any failures.
`

The agent checks the payload schema before it writes anything, then creates the case and runs it:

`bash apidog environment create gnews-free --project <projectId> --base-url https://gnews.io/api/v4 apidog cli-schema get test-case-create apidog cli-schema validate test-case-create --file case.json apidog test-case create --project <projectId> --file case.json apidog run --test-case <caseId> --project <projectId> -e <envId> --env-var "[REDACTED CREDENTIAL] -r cli,json `

Testing the NYT or GDELT instead? Put the cases in a test suite and add --delay-request 12000 to apidog run so the run respects a 5-per-minute limit. The same command with -r junit drops into a pipeline; the Apidog CLI CI/CD guide shows the GitHub Actions setup, and Apidog CLI in Claude Code walks through the agent side. Apidog's Free plan covers up to 4 users.

{% embed https://www.youtube.com/watch?v=UMl4Vo_RwkU %}

Make a 100-request quota last

Cache by query and hour. News from a 12 hour delayed feed doesn't change minute to minute. One cached call can serve every visitor for an hour.
Ask for the maximum page size. On GNews, max=10 costs the same request as max=1.
Rotate keyless sources for tech and space. Hacker News and Spaceflight News cost nothing per call, so save the keyed quota for general news.

FAQ

Is there a completely free news API with no key? Yes. GDELT DOC 2.0, the Hacker News API and the Spaceflight News API all answered real requests with no key on October 22, 2026.

Which free news API doesn't need a credit card? NewsData.io, GNews and World News API state on their pricing pages that no payment details are needed. NewsAPI and Guardian signup forms have no payment fields. Keyless APIs need no account.

Can I use a free news API in production? Usually not. NewsAPI's free plan is dev and test only, and GNews, the Guardian, NYT and Mediastack are non-commercial on free.

Why are free news API results 12 or 24 hours old? Providers delay free data to separate it from paid real-time feeds. NewsData.io and GNews delay 12 hours, NewsAPI 24 hours.

What is the best free news API for full article text? The Guardian Open Platform. Its free Developer key returns article text (show-fields=bodyText) at up to 500 calls a day, for non-commercial use.

Top 12 Free Map and Geocoding APIs

Hassann — Fri, 23 Oct 2026 04:00:16 +0000

12 个最佳的免费地图与地理编码 API

目前有 12 家提供商可以为你提供免费的地图 API，但对于“免费”的理解却千差万别。Geoapify 每天为你提供 3,000 次请求，无需信用卡，且允许商业使用。TomTom 每月为你提供 20,000 次地理编码，同样无需信用卡。Google Maps 每月为每个 SKU 提供 10,000 次调用，但需要一个付费账户。Nominatim 和 US Census Geocoder 则完全不需要 API key。

立即试用 Apidog

一览最佳的免费地图 API

免费地图 API 是指在公布的配额内可以以 $0 调用的地图、瓦片或地理编码服务。配额通常按请求、地图加载或积分计算，并每天或每月重置。一旦超出配额，大多数提供商会停止服务或开始计费。

提供商	免费配额（截至 2026-10-22 检查）	是否需要信用卡	免费层是否支持商业使用
Google Maps Platform	每月每个 SKU 10,000 次调用	是，需要付费账户	是
Mapbox	每月 50,000 次网页地图加载 + 100,000 次临时地理编码	否（在添加信用卡前会有较低的演示上限）	是
HERE Base plan	每月 30,000 次地理编码 + 30,000 次瓦片请求	是，需要付款方式	是
TomTom	每月 20,000 次地理编码 + 200,000 次瓦片请求	否	是
Esri ArcGIS Location Platform	20,000 次地理编码 + 2,000,000 次底图瓦片	仅在超出免费层时需要	是
Azure Maps	每月 5,000 次搜索 + 5,000 次地图瓦片事务	是，用于身份验证	是
Geoapify	每天 3,000 积分	否	是，需注明出处
LocationIQ	每天 5,000 次请求，每秒 2 次	未说明	有限制，需添加反向链接
Geocodio	每天 2,500 次查询	否	未说明
MapTiler Cloud	每月 5,000 次地图会话 + 100,000 次 API 请求	否	否，仅限非商业用途
OSM Nominatim	每秒 1 次请求，无需 API key	否	仅限轻度使用
US Census Geocoder	未说明配额，每个批处理文件 10,000 个地址	否	是（公共服务）

对于其他类别，请参阅我们的免费 API 指南。

无需信用卡的免费地图 API

这五家提供商可以让你在无需输入支付信息的情况下注册并发布原型。

1. Geoapify

Geoapify 的定价页面列出了免费计划中每天 3,000 积分的额度，其中简单的地理编码、地点搜索或路径规划调用会消耗 1 积分。速率限制为每秒 5 次请求。页面明确指出“无需信用卡”，FAQ 允许生产和商业使用，前提是你必须展示 “Powered by Geoapify” 以及数据来源署名。

最适适用于：需要通过一个 API key 同时使用地理编码、路径规划和瓦片服务的小型商业应用。

2. TomTom

TomTom 的开发者定价现在按月计算免费使用量，而不是按天。你每月可以获得 20,000 次地理编码和 20,000 次逆向地理编码请求，外加 200,000 次地图瓦片请求。页面明确指出“无需信用卡”。

最适适用于：在无需付费账户的情况下获得更高的每月地理编码量。

3. Mapbox

Mapbox 定价包括每月 50,000 次网页地图加载（GL JS）和 100,000 次临时地理编码请求。你可以在不绑定信用卡的情况下注册，但在添加之前，你将处于“演示访问”状态，配额上限较低（每月 5,000 次地图加载和 10,000 次临时地理编码）。永久地理编码（即存储结果）没有免费层。地理编码默认为每分钟 1,000 次请求。

最适适用于：网页或移动应用中精致的矢量地图。

4. Geocodio

Geocodio 在其按需付费计划中每天为你提供前 2,500 次免费查询，且不会累积到下一天。在超出免费层之前无需信用卡。该计划的覆盖范围仅限于美国、加拿大和墨西哥。

最适适用于：北美地区的地址地理编码和电子表格数据清洗。

5. MapTiler Cloud

MapTiler 的免费计划涵盖每月 5,000 次地图会话、1,000 次搜索会话和 100,000 次 API 请求，无需信用卡。该计划被标注用于测试、原型、个人或非商业用途，并且地图上必须保留 MapTiler 的 Logo。

最适适用于：使用自定义地图样式的个人项目和原型。

需要绑定付费账户的免费层

接下来的四家在其配额内是免费的，但你必须先绑定信用卡或付款方式。请务必在第一天就设置预算警报。

6. Google Maps Platform

Google 的定价页面为每个 Essentials SKU（包括 Geocoding 和 Dynamic Maps）提供了每个日历月 10,000 次免费的可计费事件。Maps Embed API 是无限制的。即使是免费使用，你也需要一个启用了计费功能的 Cloud 项目。地理编码结果受缓存限制约束（地点 ID 可以存储），并且你在地图上显示的结果必须显示在 Google 地图上。

最适适用于：需要 Google 地点数据和熟悉地图 UI 的应用。我们的Google Maps API 集成指南详细介绍了 API key 的设置。

7. HERE Base plan

HERE 的定价页面列出了地理编码和逆向地理编码、自动补全、矢量瓦片和栅格瓦片每月各 30,000 次免费事务，且“没有每日事务限制”。HERE 2025 年 4 月的发行说明指出，在引导注册过程中必须提供付款方式。

最适适用于：未来将发展为使用 HERE 路径规划的物流和车队原型。

8. Esri ArcGIS Location Platform

ArcGIS Location Platform 定价包含 20,000 次地理编码（非存储）、2,000,000 次底图瓦片、1,000 次底图会话和 20,000 次路径规划。计费帮助文档指出，你只需添加付款方式即可在超出免费层之外开启按需付费。存储的地理编码没有免费层。该页面按月计算费用，但没有明确说明重置周期。

最适适用于：重度 GIS 应用以及已经在使用 ArcGIS 工具的团队。

9. Azure Maps

Azure Maps Gen2 定价包含每月 5,000 次免费搜索事务、5,000 次底图瓦片事务、5,000 次地理位置定位和 1,000 次路径规划事务。Azure 的免费账户 FAQ 指出，注册需要信用卡或借记卡进行身份验证。

最适适用于：已经在使用 Azure 并希望在同一账单下使用地理编码的团队。

无需 API key 或条款受限的免费地理编码 API

10. LocationIQ

LocationIQ 的免费计划允许每天 5,000 次请求，速率为每秒 2 次请求和每分钟 60 次请求。商业使用是“受限的”：你必须添加一个可见的“Search by LocationIQ.com”链接。响应可以缓存长达 48 小时。

最适适用于：基于 OpenStreetMap 的地理编码，拥有真实的 API key 并为商业网站提供支持。

11. OpenStreetMap Nominatim

公共的 Nominatim 服务器不需要 API key，也不需要账户。Nominatim 使用政策将你的整个应用限制在每秒 1 次请求，要求提供命名你应用的 User-Agent 或 Referer，禁止自动补全和网格查询，并 discourages 批量地理编码。你必须根据 ODbL 许可协议注明 OpenStreetMap 的来源。

我们今天运行的一个测试调用返回了勃兰登堡门的坐标 52.5162699, 13.3777034：

curl -s -A "my-app/1.0 (you@example.com)" \
  "https://nominatim.openstreetmap.org/search?q=Brandenburg+Gate&format=json&limit=1"

OpenStreetMap 的标准瓦片遵循单独的瓦片使用政策：可见署名、7 天缓存且禁止批量下载。

最适适用于：低流量的工具和演示。

12. US Census Bureau Geocoder

Census Geocoder 可将美国地址与坐标和人口普查地理区域进行匹配。我们的实时调用无需 key，并将白宫匹配到经度 -77.0352，纬度 38.8987。批处理文件最多可包含 10,000 个地址。文档中没有说明速率限制，因此请自行控制调用频率。

curl -s "https://geocoding.geo.census.gov/geocoder/locations/onelineaddress?address=1600+Pennsylvania+Ave+NW,+Washington,+DC+20500&benchmark=Public_AR_Current&format=json"

最适适用于：仅限美国的地址数据、研究和公民项目。

还有两个选项存在，但条款较为严格。OpenCage 的免费层为每天 2,500 次请求，速率为每秒 1 次，仅标注用于测试。Stadia Maps 每月提供 200,000 积分，但不允许商业使用。

你应该选择哪种免费的地理编码 API？

请根据你的限制条件来选择提供商，而不是仅仅选择表格中数字最大的那一个：

无需信用卡且用于商业应用： Geoapify（每天 3,000 次）或 TomTom（每月 20,000 次地理编码）。
完全无需 API key： Nominatim 用于全球查询，Census Geocoder 用于美国地址。
批量清洗美国地址： Geocodio（每天 2,500 次）或 Census 批处理文件。
最好看的网页地图： Mapbox 或 MapTiler，具体取决于你是否用于商业目的。
已经在支付云账单： 在 Google Cloud 上使用 Google Maps，在 Azure 上使用 Azure Maps。

如果你的应用还需要天气预报，我们的天气 API 总结可以与上述任何选项完美配合。

比配额更重要的限制

免费层很少会因为调用量不足而失败，而是会因为条款问题而失败：

存储： Mapbox 临时地理编码、Esri 非存储地理编码和 Stadia 结果无法长期保存。存储它们需要付费的“永久”SKU。
署名： Geoapify、LocationIQ、MapTiler 和 OpenStreetMap 都要求在显著位置注明出处。
商业使用： MapTiler、Stadia Maps 和 OpenCage 的免费计划不适用于产生收入的商业应用。
达到上限时会发生什么： MapTiler 会暂停服务，Mapbox 演示访问会阻止所有 API 直到您添加信用卡，而 Google 或 Azure 则会开始计费。

让你的编程 AI 助手使用 Apidog CLI 进行测试

一个重试循环可能会在几分钟内耗尽一整天的免费配额。让你的编程 AI 助手一次性编写地理编码测试，并在每次代码更改时运行它们，使用 Apidog CLI。

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # 在提示时选择你的代理

然后给 Claude Code、Codex 或 Cursor 一个提示词：

In Apidog project <id>, create an environment "geoapify" with base URL
https://api.geoapify.com and a variable GEOAPIFY_KEY. Create a test case for
GET /v1/geocode/search?text=Brandenburg Gate&[REDACTED CREDENTIAL] that asserts
status 200, at least one feature, and lat between 52.5 and 52.6. Run it once
and summarize any failures. Don't run it more than 3 times.

AI 助手会读取负载 schema，验证其文件并运行测试用例：

apidog environment create geoapify --project <id> --base-url https://api.geoapify.com
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <envId> \
  --env-var "GEOAPIFY_KEY=$GEOAPIFY_KEY" -r cli,json

使用 --env-var 传递 API key 可以避免将其保存在环境中。同样的 apidog run ... -r junit 命令也可以直接集成到 GitHub Actions 中，正如我们的Apidog CLI CI/CD 指南所展示的。有关完整的代理设置，请参阅Apidog CLI in Claude Code。Apidog 的免费计划最多支持 4 个用户。

常见问题

有完全免费的地图 API 吗？ 有。Nominatim、OpenStreetMap 的标准瓦片和 US Census Geocoder 都不需要 key。公平使用规则（例如 Nominatim 上的每秒 1 次请求）将其限制在低流量应用中。

Google Maps API 是免费的吗？ 部分免费。每个 Essentials SKU（包括 Geocoding 和 Dynamic Maps）每月可获得 10,000 次免费调用，且 Maps Embed API 是无限制的。但你仍然需要一个绑定了信用卡的付费账户。

哪种免费的地理编码 API 允许在无需信用卡的情况下进行商业使用？ Geoapify 允许在其免费计划中进行商业使用（需注明出处），而 TomTom 的每月免费请求不需要信用卡。LocationIQ 允许通过添加反向链接进行有限的商业使用。

我可以存储来自免费地理编码 API 的结果吗？ 通常不行。Mapbox 临时地理编码、Esri 非存储地理编码和 Stadia Maps 限制了存储。OpenCage 允许存储，但其免费层仅用于测试。

对于个人项目来说，最好的免费地图 API 是什么？ 如果需要样式化的地图，可以使用 MapTiler 或 Mapbox，如果需要地理编码，可以使用 Nominatim 或 Geoapify。这四者都可以在不使用信用卡的情况下工作。

如何避免在 Google Maps 或 Azure Maps 上产生意外账单？ 在发布软件之前，在云控制台中设置预算警报和针对每个 API 的配额上限。

Top 8 Free AI APIs in October 2026

Hassann — Thu, 22 Oct 2026 09:47:13 +0000

Top 8 Free AI APIs in October 2026

A free AI API is an LLM endpoint you can call with an API key and pay $0 for, inside a quota the provider publishes. As of October 22, 2026, eight providers offer a free tier with no card: Google Gemini, Groq, OpenRouter, Mistral, Cloudflare Workers AI, NVIDIA's API catalog, Cohere and SambaNova. Six more give starter credits instead.

Try Apidog today

Every limit below comes from the provider's own docs, read on October 22, 2026. If you want open-weight models you can self-host, read our guide to free open-source LLM APIs instead; this post covers hosted provider free tiers only.

The 8 free LLM APIs at a glance

Provider	Free quota (official docs, 2026-10-22)	Card needed	OpenAI-compatible base URL
Google Gemini API	Free tier on Flash, Flash-Lite, 2.5 Pro and Gemma models; limits shown in AI Studio	No (billing only for Tier 1 and up)	`https://generativelanguage.googleapis.com/v1beta/openai/`
Groq	30 RPM, 1K requests/day, 8K TPM, 200K tokens/day on `openai/gpt-oss-120b`	No	`https://api.groq.com/openai/v1`
OpenRouter `:free` models	20 RPM, 50 requests/day (1,000/day after a 10-credit purchase)	No	`https://openrouter.ai/api/v1`
Mistral (Free mode)	"Usage and rate limits apply", shown in your admin panel	No	`https://api.mistral.ai/v1`
Cloudflare Workers AI	10,000 Neurons/day, resets 00:00 UTC	Not stated	`https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/v1`
NVIDIA API catalog	Free prototyping access; rate varies per model	Not stated	`https://integrate.api.nvidia.com/v1`
Cohere (trial key)	1,000 API calls/month, 20 chat requests/min	Not stated	`https://api.cohere.ai/compatibility/v1`
SambaNova Cloud	20 RPM, 20 requests/day, 200K tokens/day per model	Docs say no	`https://api.sambanova.ai/v1`

Every base URL in the table speaks the OpenAI chat completions format, so one client covers all eight.

What counts as a real free tier

A real free tier has three properties: you pay $0, you don't need to add a payment method, and the quota renews (daily or monthly) instead of running out once. A one-time credit grant is a trial, not a free tier. Credit routes get their own section below.

1. Google Gemini API

The Gemini API has the widest free model range here. The Gemini pricing page lists "Free of charge" free-tier input and output for Gemini 3.8 Flash, 3.6 Flash, 3.5 Flash-Lite, 2.5 Pro, 2.5 Flash, the Gemma 4 family and Gemini Embedding 2, among others.

What's not free: "Gemini 4 Argon is not available on the Free tier," and neither are the image, Veo or Lyria models. Google no longer prints per-model RPM and RPD numbers on its rate limits page; your active limits show in AI Studio, apply per project (not per key) and reset at midnight Pacific.

The catch is data use. Google's terms say unpaid quota content can be used to improve its products and read by human reviewers, so don't send sensitive data. Our step-by-step guide shows how to get a free Gemini API key.

2. Groq

Groq publishes the clearest free-tier numbers. Its rate limits page shows, under the Free Plan tab:

openai/gpt-oss-120b: 30 RPM, 1K requests/day, 8K tokens/min, 200K tokens/day
openai/gpt-oss-20b and qwen/qwen3.8-27b: the same limits
whisper-large-v3: 20 RPM, 2K requests/day for speech-to-text

Groq's billing FAQ asks for a payment method only "to upgrade from the Free tier to the Developer tier." The 8K tokens-per-minute cap is the one you'll hit first.

3. OpenRouter free models

OpenRouter routes to many providers, and any model ID ending in :free costs nothing. Its limits doc sets 20 requests per minute and 50 requests per day for accounts that have bought less than 10 credits in total. Buy at least 10 credits once and the daily cap rises to 1,000.

On October 22, 2026, the public models endpoint listed 18 :free IDs, including google/gemma-4-31b-it:free, nvidia/nemotron-3-super-120b-a12b:free and poolside/laguna-s-2.1:free. The list rotates monthly, which is why we keep a separate roundup of free AI models on OpenRouter.

4. Mistral (Free mode)

Mistral calls its free tier "Free mode." The quickstart states: "API access is enabled by default with no credit card required. Usage and rate limits apply."

Mistral doesn't publish the numbers. You'll find yours under Admin Panel, API, Limits. The docs also list a 402 Payment Required error for "No payment method on account," so some models or volumes may need a card.

5. Cloudflare Workers AI

Cloudflare gives every account "10,000 Neurons per day at no charge," on both the Free and Paid Workers plans, per its Workers AI pricing page. Neurons are Cloudflare's compute unit: @cf/meta/llama-3.1-8b-instruct uses 25,608 Neurons per million input tokens and 75,147 per million output tokens, so the free allocation buys roughly 130K output tokens a day on that model.

Text generation allows 300 requests per minute, and the allocation resets at 00:00 UTC. Some newer models (several Kimi, GLM and DeepSeek builds) require a paid billing method.

6. NVIDIA API catalog

NVIDIA's docs say: "Members of the NVIDIA Developer Program have free access to NIM API endpoints for prototyping." Join the free program, open a model on build.nvidia.com and generate a key.

NVIDIA staff say the old credit system was removed and the request rate "will vary per model queried." No official RPM figure is published; the "40 RPM" you'll see quoted comes from user posts, not NVIDIA. Production use needs an NVIDIA AI Enterprise license, so treat this as a prototyping route.

7. Cohere (trial key)

Cohere creates a trial key automatically when you sign up. Its rate limits doc says trial keys "are limited to 1,000 API calls a month," with 20 chat requests per minute per model, 2,000 embed inputs per minute and 10 rerank requests per minute.

The restriction: trial keys "are not permitted to be used for production or commercial purposes." The embed and rerank endpoints make it a good free route for testing retrieval, and the compatibility API runs command-a-plus-05-2026 through the OpenAI SDK.

8. SambaNova Cloud

SambaNova's rate-limit docs define the Free Tier as "applied when there is no payment method linked with your account." Each listed model, including Meta-Llama-3.3-70B-Instruct, gpt-oss-120b, DeepSeek-V3.2 and gemma-4-31B-it, gets 20 RPM, 20 requests per day and 200,000 tokens per day.

The plans page reads differently: its Free card says "Add a payment method and purchase credits to run your first requests." Twenty requests a day suits a smoke test, not a prototype.

Free AI API keys with starter credits

These are trials or need a card, so they miss the main list:

Cerebras: $5 in credits that expire 30 days after they're granted; "New accounts receive $5 in free credits after adding a verified payment method."
Vercel AI Gateway: $5 per month on a subset of "Free Tier" models; a valid payment method is required before the credits work.
Fireworks AI: a $1 starter credit, at 10 RPM with no payment method on file.
Nebius Token Factory: $1 trial credit valid for 30 days; billing setup requires a bank card.
Anthropic: "New users receive a small amount of free credits to test the API." No amount is published. We cover the details in how to get free Claude API access.
Scaleway Generative APIs: the first 1,000,000 tokens are free, with a validated payment method.

Checked and not free today

Four common answers no longer hold:

GitHub Models: "As of July 30, 2026, GitHub Models has been fully retired."
Hugging Face Inference Providers: free users get no monthly credits; PRO users get $2 a month.
Together AI: requires a $15 minimum credit purchase.
xAI and OpenAI: both run on prepaid credits. OpenAI's "Free" usage tier is a spending limit, not a credit grant.

Call any free LLM API with one client

Since all eight speak the OpenAI format, swap two values and keep your code:

import os
from openai import OpenAI

PROVIDERS = {
    "groq": ("https://api.groq.com/openai/v1", "GROQ_API_KEY", "openai/gpt-oss-120b"),
    "gemini": ("https://generativelanguage.googleapis.com/v1beta/openai/", "GEMINI_API_KEY", "gemini-3.8-flash"),
    "openrouter": ("https://openrouter.ai/api/v1", "OPENROUTER_API_KEY", "google/gemma-4-31b-it:free"),
}

base_url, key_env, model = PROVIDERS[os.environ.get("PROVIDER", "groq")]
client = OpenAI(base_url=base_url, [REDACTED CREDENTIAL]

reply = client.chat.completions.create(
    model=model,
    messages=[{"role": "user", "content": "Reply with the word ok."}],
)
print(reply.choices[0].message.content)

Wrap the call in a fallback: on a 429, move to the next provider in the dict. Our guide to handling "rate limit exceeded" errors covers backoff and retry headers.

Let your coding agent test them with Apidog CLI

Free tiers drift: a model leaves OpenRouter's free list or a daily cap drops. Rather than retest by hand, let your coding agent keep a test case per provider and re-run it through Apidog CLI. Set it up once:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Then give your agent (Claude Code, Codex, Cursor or OpenCode) one [REDACTED PROMPT]
Use Apidog CLI on project . Create one environment each for Groq, Gemini
and OpenRouter with the base URLs from this article and the key in
{{API_KEY}}. Add POST /chat/completions with a one-line prompt and model set
to {{MODEL}}. Create a test case that asserts status 200 and a non-empty
choices[0].message.content, run it in each environment, and report which
provider failed and the status code it returned.


The commands it runs, checked against `--help` on Apidog CLI 2.2.7:

bash
apidog environment create "Groq free" --project --base-url https://api.groq.com/openai/v1
apidog cli-schema get endpoint-create
apidog endpoint create --project --file chat-completions.json
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project --file case.json
apidog run --test-case --project -e -r cli,json




A 429 or 403 in the report flags a changed free tier before your users notice. Put the same `apidog run ... -r junit` on a daily schedule in CI, as shown in our [Apidog CLI CI/CD guide](http://apidog.com/blog/apidog-cli-ci-cd-pipeline?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation), or read how the agent workflow runs in [Apidog CLI with Claude Code](http://apidog.com/blog/apidog-cli-in-claude-code?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation). Apidog's Free plan covers up to 4 users.

## Which free AI API should you pick?

- **Most free models and context**: Gemini, if your data isn't sensitive.
- **Clearest published limits and fast inference**: Groq.
- **Trying many models with one key**: OpenRouter `:free`.
- **Embeddings and rerank for RAG**: Cohere's trial key.
- **Running inside Cloudflare Workers**: Workers AI.

For more ways to run models without paying, see [how to use LLMs for free](http://apidog.com/blog/use-llms-for-free?utm_source=dev.to&utm_medium=wanda&utm_content=n8n-post-automation).

## FAQ

**Is there a completely free AI API?** Yes. Google Gemini, Groq, OpenRouter's `:free` models, and Mistral Free mode all let you call an LLM at $0 without adding a card, within published or dashboard-shown limits checked on October 22, 2026.

**Which free LLM API has the highest limits?** Groq publishes the highest fixed numbers for one model: 1,000 requests and 200K tokens per day on `openai/gpt-oss-120b`. OpenRouter reaches 1,000 requests a day only after a one-time 10-credit purchase.

**Do free AI API keys expire?** Free tier keys don't expire, but quotas reset daily or monthly. Trial credits do expire: Cerebras credits last 30 days and Nebius credits 30 days.

**Can I use a free LLM API in production?** Cohere's trial keys and NVIDIA's catalog are explicitly not for production, and Gemini's free tier lets Google use your content. The other caps are too low for real traffic.

**Is the OpenAI API free?** No. OpenAI's docs grant no free API credits; its "Free" usage tier is a spending limit.

**Is GitHub Models still a free LLM API?** No. GitHub retired GitHub Models on July 30, 2026, including the playground, catalog and inference API.

Is Gemini 4 Argon Free?

Hassann — Thu, 15 Oct 2026 07:48:08 +0000

Is Gemini 4 Argon Free?

No. As of October 15, 2026, Gemini 4 Argon has no free tier. Google’s Gemini API pricing page states this directly: “Gemini 4 Argon is not available on the Free tier or on the Google AI Pro plan.” That statement applies to API access. Since Argon became generally available on October 13, every confirmed route to it has been paid: the paid Gemini API tier at $2/$10 per 1M tokens through November 30 and $4/$20 afterward, the Gemini app and Search for Google AI Pro and Ultra subscribers, and Google Antigravity for Ultra subscribers.

Try Apidog today

This guide explains every access route, its cost, the “free Argon” claims that do not hold up, the cheapest way to test the model, and the free Gemini model you can use while building your integration. For background, see what Gemini 4 Argon is; for the rollout from Fairwind-only access to general availability, see the Gemini 4 Argon release date. Apidog lets you develop against a free model first and switch to Argon by changing one variable.

Every route, and whether it gets you Argon

Route	Cost	Gets Argon?	Notes
Gemini API, paid tier	$2/$10 per 1M tokens through Nov 30, then $4/$20	Yes	Model ID `gemini-4-argon`, stable
Gemini API, free tier	$0	No	“not available on the Free tier”
Gemini app, Google AI Pro	$19.99 a month	Yes	Also available in Search
Gemini app, Google AI Ultra	$99.99 or $199.99 a month	Yes	Also in Search and Antigravity
Gemini app, free plan	$0	No	Google named Pro and Ultra only
Google AI Plus	$4.99 a month	Not named	Absent from Google’s GA announcements
Google Antigravity	Ultra plan	Ultra only	Pro and free plans not named
Cursor	$2/$10 per 1M tokens in Cursor’s listing	Yes	Added October 13
OpenCode Go	“$60 usage for $10 til Nov 30”	Yes	Low cost, not free
Gemini CLI	Paid API key only	Not confirmed	No consumer accounts since 2026-06-18
Fairwind Program	Not stated	Yes, since Sep 30	Vetted cyber defenders only
“Free Argon API” sites	Varies	Unverified	Google offers no free Argon tier
`gemini-3.8-flash` free tier	$0, rate-limited	No	The free Gemini API model you can use

The paid routes that get you Argon

The paid Gemini API

Argon appears on the Gemini API models page as gemini-4-argon, a stable model without a -preview suffix. Your project must use a paid tier, starting with Tier 1, which requires linked billing. Google says paid-tier content is not used to improve its products.

Pay-as-you-go pricing makes a test call inexpensive. With the rates available through November 30, a 2,000-token prompt and a 1,000-token answer cost:

0.002M × $2 + 0.001M × $10 = $0.014

That is cheap, but it is not free. Argon’s thinking tokens are billed as output, so the actual cost of a response can be higher than its visible text suggests.

Google AI Pro and Ultra

Google’s Gemini app announcement says, “Google AI Pro and Ultra subscribers can now access Gemini 4 Argon.” Sundar Pichai’s launch-day post adds Search access for both plans and Google Antigravity access for Ultra.

When Google’s US plans page was checked on October 1, AI Pro cost $19.99 per month. AI Ultra started at $99.99 per month with 5x Pro’s usage limits, or $199.99 per month with 20x. Google has not published per-plan Argon message limits, so Pro and Ultra should not be assumed to have the same allowance. These subscriptions are consumer plans, not API keys; the API pricing page specifically excludes the Google AI Pro plan from Argon API access.

Cursor and OpenCode Go

Cursor added Argon on October 13 and lists it at $2 per 1M input tokens and $10 per 1M output tokens, matching Google’s current rate. OpenCode added it to OpenCode Go on October 14 with the promotion “$60 usage for $10 til Nov 30.”

Both can reduce the cost of trying Argon, but neither provides free access.

Routes that do not get you Argon free

The Gemini API free tier

The Gemini API free tier still serves other models, but Argon is not one of them. An API key from a project without linked billing will not provide Argon access.

Fairwind Program

Argon launched on September 30 for selected Fairwind Program partners. Fairwind is Google’s limited-access program for vetted cyber defenders, including governments, critical infrastructure operators, and core technology platforms. It requires background checks on the applying organization and phishing-resistant MFA. Google has not stated whether Argon access through Fairwind is billed.

Fairwind was never a consumer route, and since general availability it is no longer required to use Argon.

Gemini CLI

Since June 18, 2026, Gemini CLI no longer serves Google AI Pro, Ultra, or free users. It works only with paid Gemini API or Agent Platform keys. Argon support in Gemini CLI has not been confirmed, and it would not be free in any case.

“Free Gemini 4 Argon API” sites

Google does not offer free Argon API access. Treat any site promising a free Argon API as unverified, and keep your API keys, source code, and customer data away from services that cannot be traced back to Google or a known tool vendor.

Wiz Scan for Good

Google’s launch post says Argon, used through Wiz Scan for Good, found a critical vulnerability in healthcare software used by hospitals. Google describes Scan for Good as a Wiz program “dedicated to protecting critical public infrastructure for free.”

That “free” describes what Wiz offers to infrastructure owners. It is not public Argon access.

What Argon costs

These are the Standard rates listed on Google’s pricing page, per 1M tokens, as of October 15, 2026:

Item	Through Nov 30, 2026	From Dec 1, 2026
Input	$2.00	$4.00
Output, thinking included	$10.00	$20.00
Cached input, implicit	$0.10	$0.20
Batch or Flex input / output	$1.00 / $5.00	$2.00 / $10.00

Caching is implicit only. Prompts of 4,096 tokens or more receive a 95% discount on cache hits, while explicit caching is not supported.

The only free line item is Search grounding: 5,000 free requests per month shared across Gemini 3 and later models, followed by $14 per 1,000 requests. That is free grounding on a paid model, not free model tokens. For a detailed cost walkthrough, see the Gemini 4 Argon pricing breakdown.

The free Gemini you can use today

Gemini 3.8 Flash on the API free tier

gemini-3.8-flash is Google’s stable Flash model and has a free tier in Google AI Studio and the Gemini API. It accepts 1,048,576 input tokens and returns up to 65,536 output tokens. It supports the same thinking levels as Argon—low, medium, and high—with medium as the default, which helps keep a later model switch small.

The free tier is rate-limited; current per-model limits are available at aistudio.google.com/rate-limit. Google says free-tier data is “used to improve our products,” so avoid sending confidential code or customer data through it. When you outgrow the free tier, paid pricing is $0.75/$3.75 per 1M tokens through December 31, 2026, then $1.50/$7.50.

For setup instructions, see using Gemini 3.8 Flash for free. To decide which requests belong on which model, read Gemini 4 Argon vs Gemini 3.8 Flash.

The Gemini app free plan

For chat rather than API development, the free Gemini app plan does not include Argon. When Google’s US plans page was checked on October 1, the free plan listed Gemini 3.6 Flash with varying access to Gemini 3.1 Pro.

See how to use Gemini for free for a broader look at free Gemini surfaces. If you are comparing other frontier models, the same question is covered in is Claude Opus 5.5 free.

Build free on Flash, switch to Argon with one variable

Put the model name in an environment variable and develop against gemini-3.8-flash using a free-tier key. After linking billing, point the same request at gemini-4-argon:

MODEL="${GEMINI_MODEL:-gemini-3.8-flash}"   # GEMINI_MODEL=gemini-4-argon on a paid key

curl -s "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-[REDACTED CREDENTIAL] \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"$MODEL\",
    \"input\": \"List the breaking changes in this API changelog.\",
    \"generation_config\": {\"thinking_level\": \"medium\"}
  }"

The request follows the shape of Google’s own Argon REST example. Before switching, check three items from Google’s migration checklist in the Argon developer guide:

Remove explicit caching: cachedContents, caches.create, and cached_content are not supported because Argon uses implicit caching only.
Remove temperature, top_p, and top_k; Argon ignores them.
Review max_output_tokens and increase client timeouts because difficult Argon prompts can take minutes.

In Apidog, store GEMINI_API_KEY and GEMINI_MODEL as environment variables, save the request with {{GEMINI_MODEL}} in the body, and add assertions for the response status and token counts. Keep one environment pointing to Flash and another pointing to Argon, then run the same saved request in both. That gives you a direct cost and quality comparison before moving production traffic.

FAQ

Is Gemini 4 Argon free?

No. As of October 15, 2026, it is not available on the Gemini API free tier, and the Gemini app routes require Google AI Pro or Ultra.

Can I use Gemini 4 Argon in the Gemini app for free?

No. Google names AI Pro, at $19.99 per month, and AI Ultra subscribers only.

Does Google AI Pro include Argon?

In the Gemini app and Search, yes. For the API, no: the pricing page says Argon is not available on the Google AI Pro plan. Antigravity access is named for Ultra only.

What is the cheapest way to try Argon?

Use pay-as-you-go billing on the paid Gemini API, where a short test call costs about one and a half cents. OpenCode Go’s promotion—$60 of usage for $10 until November 30—is another low-cost option.

Will Argon get a free tier?

Google has not announced one. Its previous top Pro model, Gemini 3.1 Pro Preview, also has no free API tier.

Is Fairwind still the only way in?

No. Fairwind partners received Argon first on September 30. Since October 13, any project on a paid API tier can call it. The release date guide covers each rollout stage.

Start free, keep the switch to one variable

You cannot use Argon for free, but you can build the integration around it for free. Download Apidog, point a saved request at gemini-3.8-flash on the free tier, and keep the model name in GEMINI_MODEL. When you link billing, set it to gemini-4-argon, remove unsupported caching and sampling parameters, and rerun your tests. Argon’s price doubles on December 1, so complete your comparison before then if cost is the deciding factor.

Muse Wonder Rate Limits: 3,000 RPM, 4M TPM, Shared by Your Whole Team

Hassann — Thu, 15 Oct 2026 07:47:36 +0000

Muse Wonder’s rate limits on the Meta Model API are 3,000 requests per minute and 4,000,000 tokens per minute. Both limits apply per model and per team, not per API key: every key created by your organization draws from the same shared pool. Background responses receive a separate allowance of 600 new submissions per minute. Meta publishes no usage tiers and documents no process for requesting more. When you exceed a limit, the API returns HTTP 429; Meta recommends exponential backoff with jitter starting around 500 ms and honoring Retry-After when it is present.

Try Apidog today

Those constraints determine how you should architect anything that calls muse-wonder-1.0 at scale. This article explains what the limits mean in practice, how a 1M-token context consumes a 4M TPM budget, how to interpret rate-limit headers, how to build and test a retry path, and what to do when 3,000 RPM is not enough. For API fundamentals, start with the Muse Wonder API guide.

The limits

Limit	Value	Scope
Requests per minute	3,000	Per team, per model
Tokens per minute	4,000,000	Per team, per model
Background submissions	600 per minute	Per team, on top of the above
Context window	1,048,576 tokens	Per request
Usage tiers	None published
Limit increases	No documented process

The same 3,000 RPM / 4M TPM figures apply to Muse Spark 1.3. The Contributor variant of Spark is capped lower at 150 RPM and 3M TPM. Each model has its own pool, so heavy Wonder traffic does not starve a Spark lane, and vice versa. Meta’s injected steering context is not counted against TPM and does not appear in usage.

Tokens run out before requests do

With a 4M TPM limit, the request limit is rarely the first constraint for agent workloads:

Workload	Tokens per request	Requests per minute before TPM binds
Short chat turns	3,000	1,333
Document review	50,000	80
Long agent turn with 400K context	400,000	10
Full-window request	1,000,000	4

A small set of agents using large contexts can consume 4M TPM with only a dozen concurrent requests. Cached input still counts toward TPM; prompt caching provides a billing discount, not a rate-limit discount. Reasoning tokens count toward max_output_tokens and your bill, and output tokens also count toward TPM.

Budget TPM by context size, not by request count. An agent that resends a 300K-token conversation every turn sends a 300K-token request each time. Ten such agents stepping once per minute consume three quarters of the team’s allowance.

Plan concurrency from the numbers

Use one capacity equation:

concurrent agents × tokens per turn × turns per minute per agent < 4,000,000

Calculate this for your heaviest lane before deployment.

Agents	Tokens per turn	Turns per minute each	TPM needed	Headroom
4	150,000	2	1,200,000	70%
8	250,000	1	2,000,000	50%
12	300,000	1	3,600,000	10%
20	300,000	1	6,000,000	Over the limit

Leave at least 40% headroom. Agent traffic is bursty, retries can briefly double demand, and every other team member consumes the same pool. A configuration with only 10% theoretical headroom can fail as soon as two agents retry simultaneously.

Two levers reduce demand. First, compaction prevents context growth from becoming unbounded: summarize or remove old tool results after a threshold, as described in the context window guide. Second, stateless encrypted replay on the Responses API lets you control exactly what is resent. Server-managed history with previous_response_id, by contrast, resends everything.

One pool for every key

Meta scopes rate limits per team. Staging, production, and developer-laptop API keys all consume the same 3,000 RPM / 4M TPM pool.

That has two operational consequences. A load test run by one developer can throttle production, so isolate experiments by time or use a separate team when your organization permits it. Also, per-key monitoring cannot show the full picture. Aggregate x-ratelimit-* headers across every caller; otherwise, you may see 429s on a key that appears to be well below its own apparent limit.

Read the headers

Token-based responses include x-ratelimit-* headers. Log them on every call. The important signal is remaining capacity trending toward zero across all callers within a minute—that is your warning to slow down before a 429 occurs. Transcription responses do not include these headers, but Wonder responses do.

When a 429 arrives, Meta’s guidance is specific: use exponential backoff with jitter starting around 500 ms, and wait at least the duration specified by Retry-After when present. A retry loop that ignores Retry-After and retries at a fixed interval extends the throttling period for the entire team.

Build the retry path

import os
import random
import time

from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.meta.ai/v1",
    [REDACTED CREDENTIAL],
)

def call(input_text, attempts=6):
    delay = 0.5

    for attempt in range(attempts):
        try:
            return client.responses.create(
                model="muse-wonder-1.0",
                input=input_text,
                reasoning={"effort": "medium"},
                max_output_tokens=4096,
            )
        except RateLimitError as error:
            if attempt == attempts - 1:
                raise RuntimeError("rate limited after retries") from error

            retry_after = error.response.headers.get("Retry-After")
            fallback_delay = delay + random.uniform(0, delay)
            wait = (
                max(float(retry_after), fallback_delay)
                if retry_after
                else fallback_delay
            )

            time.sleep(wait)
            delay = min(delay * 2, 30)

Three design points matter. Cap the backoff so a prolonged outage does not produce a 20-minute sleep. Keep retries idempotent: repeating a Responses API call that creates nothing on your side is safe, but if your agent’s tool calls have side effects, retry the model call rather than the tool. Finally, record retries in traces so you can distinguish a slow model response from a throttled one. The tool-call tracing guide covers what to log.

Use background responses for the long tail

Long-running jobs do not need to hold an open connection. Setting background: true queues the response, returns "status": "queued", and lets you poll GET /v1/responses/{id}?stream=true for lifecycle events.

Background submissions have their own 600-per-minute allowance in addition to the main limits, so moving batch-style work there can free RPM for interactive traffic. Constraints include:

No stream: true on the POST request.
A 1 MiB request-body cap.
Cancellation through POST /v1/responses/{id}/cancel.

When 3,000 RPM is not enough

Meta publishes neither a tier ladder nor a limit-increase form. Your current options are:

Reduce tokens per request. Prompt caching reduces cost but not TPM consumption. Trimming context reduces both. The context window guide explains how to trim tool results.
Spread work across models. Muse Spark 1.3 has its own 3,000 RPM / 4M TPM pool at one third of the price. Route work that does not require Wonder’s quality to Spark.
Use a gateway. Vercel AI Gateway and Cloudflare Workers AI serve meta/muse-wonder-1.0. Whether that provides a separate allowance depends on how the gateway is provisioned, so confirm with the provider before relying on it.
Queue and smooth traffic. A central token-bucket limiter that knows the team’s full budget will perform better than multiple services independently guessing at capacity.

Test limit handling in Apidog

Do not wait until request 3,001 to discover a retry bug. In Apidog:

Build the Responses request with MODEL_API_KEY stored as a secret variable. Add a post-processor that reads x-ratelimit-* headers into environment variables so a scenario can assert that remaining capacity never drops below a chosen floor.
Create a mock for /v1/responses with an expectation that returns 429 and Retry-After: 2 when a request includes a test header such as X-Test-Scenario: throttle. Point your client at the mock and verify that it waits at least two seconds and succeeds on the next attempt.
Run a performance test that ramps request volume against the mock to confirm your limiter engages before the real API would throttle.
Add the scenario to CI with the Apidog CLI so retry changes cannot ship without passing the test.

Download Apidog to set up the mock, assertions, and performance scenario in one project.

Frequently asked questions

Are Muse Wonder rate limits per key or per account?

Per team. Every key in a team shares one 3,000 RPM / 4M TPM pool per model.

Does cached input count toward TPM?

Yes. Caching lowers the price of those tokens, not their weight against the per-minute token limit.

Can I request a higher limit?

Meta’s pricing and rate-limits page currently lists no tiers and no request process. Check the page for changes; new tiers may appear after frontier-model launches.

What status code and headers do I get?

HTTP 429, optionally with Retry-After, plus x-ratelimit-* headers on token-based responses.

Next step

Measure the tokens per request for your heaviest agent turn, multiply by concurrency and turns per minute, then compare the result with 4,000,000. If the number is close to the limit, build the central limiter and mock test now—before the whole team starts sharing the pool with production.

Gemini 4 Argon is OUT

Hassann — Thu, 15 Oct 2026 07:47:21 +0000

Gemini 4 Argon is OUT

Gemini 4 Argon reached developers on October 13, 2026. Google made gemini-4-argon generally available on the paid tier of the Gemini API, brought it to Google AI Pro and Ultra subscribers in the Gemini app and Search, and made it available to Ultra subscribers in Google Antigravity. The original announcement came on September 30, 2026, for a limited set of Fairwind Program cyber defenders. The next major date is December 1, 2026, when API pricing doubles from $2/$10 to $4/$20 per 1M tokens.

Try Apidog today

Here is the full release timeline, Argon availability by channel, how the Fairwind phase worked, what Google has not clarified, and how to verify that your API key can call the model. For a model overview, start with what Gemini 4 Argon is. For pricing eligibility, see whether Gemini 4 Argon is free. If you call it from code, keep your requests in Apidog and store the model name in an environment variable.

The Gemini 4 Argon timeline

Argon emerged from a summer of cyber-tuned Flash models distributed to a small group of defenders, then became broadly available 13 days after its announcement.

Date	Event	Source
2026-07-21	Gemini 3.5 Flash Cyber launches as a “limited-access pilot” for governments and trusted partners	Google DeepMind blog
2026-09-02	Fairwind Program launches with Gemini 3.8 Flash Cyber and CodeMender, with 650+ partners	blog.google
2026-09-24	Kavukcuoglu says Gemini 4 is in post-training and coming “as soon as possible”	9to5Google
2026-09-30	Gemini 4 Argon announced; rolling out only to a set of Fairwind partners	blog.google
2026-10-13	GA: `gemini-4-argon` on the paid Gemini API; Pro and Ultra in the Gemini app and Search; Ultra in Antigravity	Gemini API changelog, Sundar Pichai
2026-10-13	Cursor adds Argon at $2/$10 per 1M tokens	Cursor
2026-10-14	OpenCode adds Argon to OpenCode Go	OpenCode
2026-11-30	Last day of the $2/$10 API rate	Gemini API pricing page
2026-12-01	API price rises to $4/$20 per 1M tokens	Gemini API pricing page

Earlier models in this line followed a defender-first pattern: Gemini 3.5 Flash Cyber never received a public API, while Gemini 3.8 Flash Cyber remained behind an allowlist as of October 1. Argon began similarly but reached public availability within two weeks.

On September 24, 9to5Google reported that Kavukcuoglu told The Information’s AI Agenda Live summit that Google hoped to ship Gemini 4 “much earlier” than the end of 2026. It did.

Reuters described Argon as arriving “after months of delays,” because Sundar Pichai had previously said Gemini 3.5 Pro would ship in June before Google dropped that plan.

The Gemini API changelog entry dated October 13, 2026 lists gemini-4-argon as “generally available,” and the models page labels it “New Stable.” There is one version, with no -preview suffix.

GA also clarified previously unavailable specifications:

Argon has a unified 1,048,576-token context window shared by input, thinking, and output.
Synchronous requests return 65,536 output tokens by default.
Long decode in background mode on the Interactions API can reach approximately 1M tokens.
Supported thinking levels are low, medium, and high; medium is the default.
If you are porting Gemini 3.x code, remove temperature, top_p, and top_k because Argon ignores them.
Remove explicit caching configuration; explicit caching is not supported, while implicit caching is enabled by default.

Who has Argon, channel by channel

On October 13, Sundar Pichai said Argon is “available globally today for developers and enterprises in the paid tier of the Gemini API and the Gemini platform, for Ultra subscribers in Google Antigravity, and Ultra and Pro subscribers in the Gemini app and Search.”

Channel	Who	Status as of October 15, 2026
Gemini API	Paid-tier projects	GA since October 13, model `gemini-4-argon`
Gemini API free tier	Everyone else	Not available
Gemini app	Google AI Pro and Ultra subscribers	Available since October 13
Search	Google AI Pro and Ultra subscribers	Available since October 13
Google Antigravity	Ultra subscribers	Available since October 13
Enterprises	“The Gemini platform”	Named by Google; Vertex AI not confirmed
Cursor, OpenCode Go	Their users	Added October 13 and 14
Fairwind Program	A set of partners	Since September 30

Google’s pricing page states plainly: “Gemini 4 Argon is not available on the Free tier or on the Google AI Pro plan.” That statement refers to API plans; Pro subscribers still receive Argon in the Gemini app and Search. A consumer subscription is not an API key.

Through November 30, 2026, Argon API usage costs $2 per 1M input tokens and $10 per 1M output tokens. Starting December 1, those rates become $4 and $20. See the Argon pricing guide for detailed cost calculations.

The Fairwind Program: where Argon started

Before GA, Fairwind was the only entry point. The program provides “high-priority defenders (like governments, healthcare providers, and telecommunications services) early access to advanced models.” Google says it works “with over 650 partners globally.” At launch, the Fairwind page stated: “A set of Fairwind Program partners get exclusive access to Gemini 4 Argon, and can use this model in CodeMender.” Membership did not automatically include Argon access.

Google summarized the phased rollout in one line: “Safely releasing frontier capabilities at this level requires a phased approach.” At announcement, it said trusted defenders and internal teams would receive Argon without cyber guardrails. Our Argon cyber defense breakdown explains what that means for the APIs you operate.

Who can apply

The Fairwind FAQ lists three eligible groups, without ranking them:

Governments and national cyber authorities
Critical infrastructure operators in healthcare, telecommunications, energy, and financial networks
Core technology platforms that secure widely used software foundations

All applicants need “a proven track record of ethical operations and research.” Academic labs focused on defensive benchmarking may also apply. Students are directed to CodeMender on Google Cloud. Private companies are not excluded because many infrastructure operators and technology platforms are private.

What you commit to

Fairwind is not a simple waitlist. Google conducts background checks on applying organizations, and approved partners accept operating requirements:

Use “user-level authentication, phishing-resistant MFA, and applicable access controls.”
Limit Argon access to “internal cybersecurity, incident response, or penetration testing teams.”
Track employee access and use.
Do not share, redistribute, or resell access.

How to apply and how access is delivered

Apply through the Fairwind interest form. Google says it will “review and respond to eligible partners who meet our criteria as soon as we can,” but it has not published a response time. Approved partners use Argon on Gemini Enterprise: “When accessed directly as a managed model on Gemini Enterprise, Gemini 4 Argon supports zero data retention.”

What Google hasn’t said

As of October 15, 2026, these points remain unclear:

Vertex AI and Gemini Enterprise Agent Platform: Pichai named “the Gemini platform” for enterprises, but Google has not confirmed an Argon listing on Agent Platform. One report says its release notes do not yet list Argon.
Gemini app limits: Google has not published Argon message limits for Pro and Ultra subscribers.
Per-model API rate limits: RPM, TPM, and RPD limits are not in the docs; AI Studio shows the limits for your project.
Knowledge cutoff: Not published.
Gemini CLI: Google has not confirmed Argon support there.
Fairwind review time and partner count: Neither has been disclosed.

How to confirm your key can call Argon

Launch day has passed, but the same checks now tell you whether your key can call Argon and what model metadata it exposes.

Check the changelog and models page. Both list gemini-4-argon as of October 13.

Poll models.list. The Gemini API returns every model visible to your key. On October 1, 2026, this request returned 61 models and no Argon match:

curl -s "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000" \
  -H "x-goog-[REDACTED CREDENTIAL] \
  | jq -r '.models[] | select(.name | test("argon"; "i")) | "\(.name) out=\(.outputTokenLimit)"'

Each model entry includes name, inputTokenLimit, outputTokenLimit, supportedGenerationMethods, and thinking. If the request returns no Argon result, first confirm that the key belongs to a billing-enabled project because Argon is not available on the free tier.

Turn the request into an automated check. Save the same GET request in Apidog, store GEMINI_API_KEY as an environment variable, and add a post-processor script that fails when Argon is missing:

const models = pm.response.json().models || [];
const hits = models.filter(model => /argon/i.test(model.name));

pm.test("Argon is visible to this key", () => {
  pm.expect(hits.length).to.be.above(0);
});

if (hits.length) {
  console.log(
    hits
      .map(model => `${model.name} out=${model.outputTokenLimit}`)
      .join("\n")
  );
}

Add the request to a test scenario, run it through Apidog scheduled tasks or CI with the Apidog CLI, and connect a notification. A revoked key or billing problem then appears as a failed test rather than a production error.

Store GEMINI_MODEL=gemini-4-argon alongside the key. Price saved requests at the December rates so the upcoming change appears in tests before it appears on an invoice. The Argon API guide covers request shapes in detail.

FAQ

What is the Gemini 4 Argon release date?

October 13, 2026, for developers on the paid Gemini API and for Pro and Ultra subscribers in the Gemini app. Google announced it on September 30, 2026, for Fairwind partners only.

Can I use Gemini 4 Argon now?

Yes, with a paid-tier Gemini API key, a Google AI Pro or Ultra subscription in the Gemini app and Search, or an Ultra subscription for Antigravity. Cursor and OpenCode Go also offer it. There is no free API tier; for a model with one, the Gemini 3.8 Flash API guide walks through a first call.

When does the Gemini 4 Argon price change?

November 30, 2026 is the last day at $2/$10 per 1M tokens. From December 1, the API rate is $4/$20.

Do Google AI Pro subscribers get Argon?

Yes, in the Gemini app and Search. They do not get API access through Pro, and Google named only Ultra subscribers for Antigravity.

What is the Gemini 4 Argon model ID?

gemini-4-argon. It is the stable version and has no -preview suffix.

What to do before December 1

If you build on the Gemini API, move a test workload to gemini-4-argon while the $2/$10 rate remains active, measure real token consumption, and model future costs at $4/$20 so the December bill contains no surprises. If you manage security for a qualifying organization, Fairwind remains the route to Argon on Gemini Enterprise with zero data retention.

Download Apidog to keep the access check, regression requests, and cost assertions in one workspace.

Muse Wonder vs Claude Opus 5.5: Same Price, Different Jobs

Hassann — Thu, 15 Oct 2026 07:40:46 +0000

Muse Wonder and Claude Opus 5.5 have identical first-party API pricing: $4 per million input tokens, $20 per million output tokens, and $0.20 per million cached input tokens. Both expose a 1M-token context window. That removes price from the initial comparison and leaves a simpler question: which model does the work better? On Artificial Analysis’ independent index, Opus 5.5 scores 58 versus Wonder’s 52. On Meta’s agentic benchmarks, Wonder Full leads some long-running coding and legal tasks, while the API-available Wonder also beats Opus on SWE-Marathon. Artificial Analysis measured Wonder at $4.52 per index task versus $5.98 for Opus.

Try Apidog today

This comparison covers specifications, benchmarks, per-task cost, tooling, data terms, and practical model selection. For a standalone introduction to Meta’s model, see the Muse Wonder explainer.

Specs

	Muse Wonder	Claude Opus 5.5
Model ID	`muse-wonder-1.0`	`claude-opus-5-5`
Input / output / cached per 1M	$4 / $20 / $0.20	$4 / $20 / $0.20 cache read
Context	1M tokens	1M tokens
Inputs	Text, image, video, audio	Text, image, PDF
API formats	Responses, Chat Completions, Messages	Messages, plus an OpenAI-compatible endpoint
Reasoning control	`effort` from `minimal` to `max`; always reasons	`effort` levels; extended thinking
First-party rate limits	3,000 RPM and 4M TPM per team	Tiered by spend
Larger sibling	Muse Wonder Full, available only in Muse Code	None
Weights	Closed	Closed

Two distinctions matter before benchmarks. Wonder accepts video and audio natively; Opus does not. Opus is Anthropic’s strongest model, while Wonder is the smaller of Meta’s two models. When Meta publishes charts showing a win over Opus, check whether the result belongs to Wonder or Wonder Full.

Benchmarks: Meta’s table

Meta’s model card reports the following results at maximum effort for the API-available Muse Wonder and Claude Opus 5.5:

Benchmark	Muse Wonder	Claude Opus 5.5	Winner
Artificial Analysis Intelligence Index	52	58	Opus 5.5
Harvey LAB-AA, legal	10.0	4.2	Wonder
AutomationBench-AA	39.1	41.2	Opus 5.5
JobBench	70.5	75.4	Opus 5.5
DeepSWE 1.1	78.8	74.2	Wonder
SWE-Marathon	53.1	46.3	Wonder
Terminal-Bench 4.0-AA	52.0	59.6	Opus 5.5
HealthBench Pro	60.5	65.6	Opus 5.5

Opus wins five of eight rows on Meta’s own table. Wonder wins both software-engineering benchmarks and the legal benchmark. Its 6.8-point SWE-Marathon lead is the most relevant signal for long-running coding agents that need to continue through many steps and blockers.

Benchmarks: the independent view

Artificial Analysis tested both models at maximum effort:

Measure	Muse Wonder	Claude Opus 5.5
Intelligence Index v4.3	52	58
AA-Omniscience, knowledge	25	46
Hallucination rate	27%	Not in the same table
GDPval-AA, Elo	n/a; Wonder Full scored 1857	1866
Coding Agents Index	63	66 with Claude Code
Output tokens per index task	~54,000	Not stated
Cost per index task	$4.52	$5.98

The knowledge gap is the largest difference in either direction: Opus scores 46 versus Wonder’s 25 on AA-Omniscience. Retrieval-heavy applications should therefore treat grounding as mandatory for Wonder, while Opus may need less retrieval support for some factual workflows. On coding agents, Claude Code with Opus scores 66 versus 63 for Wonder; Wonder Full reaches 68, but it has no API.

Cost per task, not per token

The rate cards are identical, but actual bills differ. Artificial Analysis measured Wonder at $4.52 per index task and Opus at $5.98. Wonder’s profile is cache-heavy: only $1.08 of its $4.52 came from output tokens, while $3.43 came from input, mostly cache writes and reads. Opus spent proportionally more on output.

Use the workload, not the token price, to decide:

Long agentic loops with a stable prefix: Wonder’s cache-heavy profile can be advantageous because cached input costs $0.20 per million tokens.
Short prompts with long generated answers: Output volume dominates, so the effective gap narrows.
Any production workload: Inspect usage on every response and calculate cost from your own traffic.

A simple cost calculation for either model is:

cost = (input_tokens × 4 / 1_000_000)
     + (output_tokens × 20 / 1_000_000)
     + (cached_input_tokens × 0.20 / 1_000_000)

The Opus 5.5 caching math and Muse Wonder pricing posts walk through detailed examples.

Tooling and ecosystem

Claude Opus 5.5 has the broader ecosystem: Claude Code, the Agent SDK, Managed Agents, Amazon Bedrock, Google Cloud, Microsoft Foundry, and substantial third-party integration support. Its 18-hour task API design is particularly relevant for long-horizon agents.

Muse Wonder launched on October 12, 2026, so its ecosystem is still new. It supports Meta’s API with three request formats, Muse Code, Vercel AI Gateway, and Cloudflare Workers AI. Meta’s documentation explains how to point Claude Code and Codex at api.meta.ai, making it straightforward to test existing agent harnesses against Wonder. However, Meta does not yet offer an equivalent of Managed Agents. Its zero-data-retention mode also disables server-side state, background requests, file uploads, and web search.

Muse Code also had a launch-week quota-drain bug, which Meta fixed the same day. Treat the ecosystem as promising but early.

Safety and data

Both vendors recommend human confirmation before consequential agent actions. Meta trained Wonder to check in before important actions and avoid sharing private information without permission. Its full safety report was still pending, and Meta could not rule out high-risk chemical and biological capabilities without safeguards.

Anthropic publishes system cards at launch. Its reported 85% prompt-injection resistance figure is covered in more detail in the Opus 5.5 prompt injection analysis.

Data handling also differs. Meta’s API Standard mode does not train on customer traffic, but Muse Code subscriptions default to Contributor mode, which does. Anthropic does not train on API traffic by default.

Which model should get which job?

Job	Better pick	Why
Long-running coding agents with many steps and blockers	Try Wonder	SWE-Marathon: 53.1 versus 46.3; cache-heavy cost profile
Legal document agents	Try Wonder	Harvey LAB: 10.0 versus 4.2
Factual Q&A and research assistants	Opus 5.5	AA-Omniscience: 46 versus 25
Terminal and DevOps agents	Opus 5.5	Terminal-Bench: 59.6 versus 52.0
Health and professional advice	Opus 5.5	HealthBench Pro: 65.6 versus 60.5
Video or audio input	Wonder	Opus does not accept them
Workloads requiring Bedrock, Google Cloud, or Foundry	Opus 5.5	Wonder is available first-party, through Vercel, and through Cloudflare
Interactive coding with the strongest available model	Opus through the API, or Wonder Full through Muse Code	Wonder Full is subscription-only

The practical conclusion is straightforward: Opus 5.5 is the stronger general model and the safer default. Wonder is worth testing for long agentic tool-using workloads, legal document tasks, and applications that need native video or audio input.

Run the comparison in Apidog

Because Wonder supports OpenAI-style and Anthropic-style interfaces and Opus supports Anthropic Messages plus an OpenAI-compatible endpoint, one [Apidog](https://apid - Meta: base_url = https://api.meta.ai/v1

Anthropic: use Anthropic’s Messages base URL
1. Store each API key as a secret environment variable.
2. Build one Responses request for Wonder use the response usage fields directly:

const usage = pm.response.json().usage;

const inputCost = (usage.input_tokens ?? 0) * 4 / 1_000_000;
const outputCost = (usage.output_tokens ?? 0) * 20 / 1_000_000;
const cacheCost = (usage.cached_input_tokens ?? 0) * 0.20 / 1_000_000;

pm.collectionVariables.set("run_cost_usd", inputCost + outputCost + cacheCost);

Adjust the usage field names if a provider returns cache details in a nested object. Ten representative tasks from your own workload will provide more useful evidence than either vendor’s benchmark table. Download Apidog to run the models side by side.

Frequently asked questions

Is### Are Muse Wonder and Claude Opus 5.5 the same price?

Yes, on list price: $4 per million input tokens, $20 per million output tokens, and $0.20 per million cached input tokens. Per index task, Artificial Analysis measured Wonder at $4.52 and Opus at $5.98.

Which model is better for Claude Code?

Claude Code was built for Claude. It can also target Wonder through Meta’s Messages endpoint. In the Coding Agents Index, Claude Code with Opus scores 66 versus 63 for Wonder. Wonder Full closes the gap, but it has no API and is available only through Muse Code.

Does Muse Wonder Full change the recommendation?

It changes the benchmark picture: Wonder Full scores 56 on the index and leads most agentic rows. Operationally, it only matters if you can work inside Muse Code because Full cannot be deployed through the API.

Next step

Select your longest representative agent task, run it through both models at your intended effort level, and compare intervention frequency, output quality, completion rate, and usage. Since list price is identical, let task performance and actual token consumption decide.

Muse Wonder vs Muse Wonder Full

Hassann — Thu, 15 Oct 2026 07:36:21 +0000

Muse Wonder vs Muse Wonder Full

Muse Wonder and Muse Wonder Full are two sizes of the same Meta model family, released together on October 12, 2026. Wonder is the model developers can call directly: muse-wonder-1.0 is available through the Meta Model API at $4 per million input tokens and $20 per million output tokens, and it is included in every Muse Code plan. Wonder Full is the model behind Meta’s headline benchmark results: it scores four points higher on the Artificial Analysis index, leads on long coding runs and legal work, and is available only through Muse Code Power or Maximum subscriptions at $50 or $200 per month. It has no public API and no published per-token price.

Try Apidog today

For developers, that access split is the main decision. This guide compares the two models feature by feature, explains where Full performs better, breaks down the practical costs, and shows how to choose the right model for coding, evaluation, and production use. If the Muse family is new to you, start with the Muse Wonder explainer.

Side by side

	Muse Wonder	Muse Wonder Full
Model ID	`muse-wonder-1.0`	`muse-wonder-full-1.0` (Muse Code only)
API access	Yes: Responses, Chat Completions, Messages	No
Muse Code plans	Everyday ($5) and above	Power ($50), Maximum ($200)
Per-token price	$4 input / $20 output / $0.20 cached input	None published
Context window	1M tokens	1M tokens
Inputs	Text, image, video, audio	Same
Artificial Analysis Intelligence Index	52	56
Coding Agents Index	63	68
Hallucination rate, Artificial Analysis	27%	23%
Third-party gateways	Vercel, Cloudflare	None
Weights	Closed	Closed

The architectural capabilities Meta highlights apply to both models: Active Memory, Active Focus, multimodal input, computer use, and sub-agent delegation. The practical difference is scale. Meta says Full performs better on unfamiliar tasks than the Muse Spark trend line predicted, and attributes that result to its larger base model.

Where Full pulls ahead

Meta’s model-card results below were run at maximum reasoning effort:

Benchmark	Wonder Full	Wonder	Gap
Harvey LAB-AA, legal	13.1	10.0	+3.1
AutomationBench-AA	45.4	39.1	+6.3
JobBench	75.3	70.5	+4.8
SWE-Marathon	57.5	53.1	+4.4
Terminal-Bench 4.0-AA	57.1	52.0	+5.1
HealthBench Pro	62.3	60.5	+1.8
DeepSWE 1.1	79.0	78.8	+0.2

The independent Artificial Analysis evaluation points in the same direction. Full scores 56 versus Wonder’s 52 on the composite index, 57% versus 52% on Terminal-Bench 4.0, and 68 versus 63 on the Coding Agents Index. It also hallucinates less: 23% versus 27%. On Meta’s internal FocusBench, which measures the persistence behavior behind Active Focus, Full leads every evaluated model at 54.2%, while Wonder scores 44.9% and trails both GPT-6 Astra and Claude Opus 5.5.

Memory is the exception. On Meta’s MemoryBench, Wonder narrowly beats Full, 85.6 to 85.5, which makes that capability effectively a wash.

The performance gap is therefore real but uneven. On short software tasks such as DeepSWE, the difference nearly disappears. On long, blocker-heavy coding work—the category Meta designed the family for—Full leads by roughly four to six points. On the Coding Agents Index, Full ties Claude Code running Sonnet 5.5 at 68 and beats Opus 5.5 at 66, while Wonder trails all three at 63.

What each model costs

Muse Wonder

Wonder uses token-based pricing. Artificial Analysis measured its cost at $4.52 per Intelligence Index task at maximum effort, compared with $5.98 for Claude Opus 5.5 and $3.26 for GPT-6 Astra.

Agentic workflows often resend a growing context, so cached input can dominate the bill. At $0.20 per million cached input tokens, that can substantially reduce the effective cost of long coding sessions. The Muse Wonder pricing guide walks through the cost examples.

Muse Wonder Full

Full has no token price, so there is no meaningful per-task API cost figure. Its price is the subscription:

Plan	Monthly price	Usage allowance
Muse Code Power	$50	20x Everyday
Muse Code Maximum	$200	80x Everyday

Both plans use five-hour and weekly usage resets. For an individual developer who codes throughout the day, $50 per month can be inexpensive compared with API usage on another frontier model. For a team that wants to expose Full behind its own product, however, there is no supported path at any price.

The data terms also matter. Muse Code subscriptions default to Contributor mode, which allows Meta to train on prompts, code, and outputs. API traffic in Standard mode is not used for training. You can turn Contributor mode off with one toggle, but it remains enabled until you do so.

Which model can you build on?

This is the practical dividing line. Anything shipped to users runs on Wonder because Full has no API, no third-party gateway, and no SDK. Full’s launch benchmarks are real, but they describe a tool you can use yourself—not a model you can resell or embed in a product.

Goal	Best choice
Call the model from your product	Wonder, through the API
Run Claude Code or Codex on a Meta model	Wonder, through Messages or Responses
Code in a terminal with Meta’s strongest model	Full, through Muse Code Power or Maximum
Evaluate Meta’s frontier claims	Test Full in Muse Code, then test Wonder for deployment
Pay only for what you use	Wonder

Meta’s developer blog says Full is available only through Muse Code subscriptions and gives no timeline for API access. Until that changes, be careful with benchmark tables comparing “Muse Wonder” to other APIs: if the score belongs to Full, it does not describe the API model.

What the access wall costs in practice

You run Claude Code or Codex against Meta’s API

Meta’s coding-agents guide shows both harnesses pointed at api.meta.ai, with muse-wonder-1.0 as the main model and Muse Spark 1.3 handling subagents and background tasks. That configuration gives you Wonder, which scores 63 on the Coding Agents Index.

The 68 score that ties Claude Code running Sonnet 5.5 belongs to Full inside Muse Code. If that benchmark is your reason for changing harnesses, this setup will not deliver it.

You are comparing vendors for a product

Every Full result in Meta’s launch table is irrelevant to procurement because no external product can call Full. For a deployable comparison, use Wonder’s numbers: 52 on the Artificial Analysis index, 53.1 on SWE-Marathon, and 25 on knowledge. Compare those directly against models your product can actually access.

You are unsure which model answered

In Muse Code, open the /models menu to see the active model. A response that calls itself “Wonder” is not reliable evidence of which model produced it, and the --reasoning-effort flag does not switch models.

On the API, the model field in every response identifies muse-wonder-1.0. There is no Full model on the API to confuse it with.

Meta’s own benchmark data explains why this check matters: on short tasks, the two models are within a fifth of a point. You may not notice which one responded until the work becomes long enough for Full’s advantage to appear.

Test the difference on your own work

If you have Muse Code Power, measure the gap with a task that reflects your real workload:

Choose one long task, such as a 30-step refactor or a multi-file code review.
Run it with --model muse-wonder-1.0.
Switch to Full through the /models menu.
Run the same task again.
Compare the finished result and the number of manual interventions.

That test tells you whether Full’s four-point overall advantage matters for your kind of work.

For the API side, use Apidog to verify that Wonder—not a benchmark headline—meets your quality bar. Store the API key as a secret variable, send your real prompts at medium and max reasoning effort, assert on the response shape, and inspect the usage field to calculate cost. The Muse Wonder API guide includes the requests. You can also [download and no third-party gateway. Meta has not announced a release date for API access.

Does maximum reasoning effort turn Wonder into Full?

No. Reasoning effort controls how long Wonder reasons. The model ID remains unchanged.

Is Full worth $50 per month if Wonder starts at $5?

For solo work on long coding tasks, the gaps are meaningful: 68 versus 63 on the Coding Agents Index and is the only version you can build with. Use%;">

Muse Wonder Benchmarks

Hassann — Thu, 15 Oct 2026 07:30:04 +0000

Muse Wonder Benchmarks

Muse Wonder Full scores 56 on the Artificial Analysis Intelligence Index, while Muse Wonder scores 52. That places them behind Claude Opus 5.5 at 58, level with Claude Sonnet 5.5 at 56 for Full, and close to GPT-6 Astra, Gemini 4 Argon, and Claude Fable 5.1 at 53 each. Meta’s model card tells a different story: Wonder Full leads on long-running coding, legal work, business automation, and memory. Both claims can be true because they measure different capabilities. That distinction is the most useful takeaway from these results.

Try Apidog today

Below is the full published picture: Meta’s numbers, independent Artificial Analysis results, the specific areas where Wonder leads, where it trails, and which benchmarks cannot currently be reproduced outside Meta. For a broader explanation of the model itself, see the Muse Wonder explainer.

Meta’s model card table

Meta compared Muse Wonder Full, Muse Wonder, GPT-6 Astra, and Claude Opus 5.5 at maximum reasoning effort. The table below follows VentureBeat’s report on Meta’s model card.

Benchmark	What it measures	Wonder Full	Wonder	GPT-6 Astra	Claude Opus 5.5
Artificial Analysis Intelligence Index	Ten-eval composite	56	52	53	58
Harvey LAB-AA	Legal agent tasks	13.1	10.0	8.6	4.2
AutomationBench-AA	Business process automation	45.4	39.1	41.6	41.2
JobBench	Professional work	75.3	70.5	66.1	75.4
DeepSWE 1.1	Software engineering	79.0	78.8	74.1	74.2
SWE-Marathon	Long-running coding runs	57.5	53.1	42.5	46.3
Terminal-Bench 4.0-AA	Terminal agent tasks	57.1	52.0	59.1	59.6
HealthBench Pro	Health questions	62.3	60.5	65.3	65.6

The pattern is clear. Wonder Full performs best when a task is long-running and agentic: it leads SWE-Marathon by 11 points over Opus 5.5, DeepSWE by five points, and Harvey LAB by roughly a factor of three. It trails on terminal work, health questions, and the aggregate intelligence index. Even in Meta’s own table, Opus 5.5 is the stronger general model; Wonder Full is the more persistent one.

Meta states two important caveats. First, competitor runs were best-effort and may not have used optimal settings for those models. Second, some coding comparisons used different tooling, making those rows less controlled than the rest.

Meta’s internal benchmarks: memory and focus

Three figures in Meta’s launch material come from tests that only Meta can currently run.

Benchmark	Wonder Full	Wonder	GPT-6 Astra	Claude Opus 5.5	Claude Fable 5.1
MemoryBench	85.5	85.6	81.4	81.5	79.0
FocusBench	54.2	44.9	47.7	45.8	36.6

MemoryBench places facts inside conversations of 64K to 100K tokens, adds distractors, and changes some facts partway through. The model must recall the current version of each fact. This is the evidence behind Meta’s Active Memory feature.

FocusBench measures whether a model continues pursuing a goal when it encounters blockers. That corresponds to the Active Focus feature. Note that the smaller Wonder model scores below both GPT-6 Astra and Claude Opus 5.5 on FocusBench; only Wonder Full leads. The third internal figure, the Personal Superintelligence Index, has no published competitor comparison.

These benchmarks plausibly test real behaviors, but they also test exactly the behaviors Meta trained for. Until outside evaluators can reproduce them, treat them as evidence of Meta’s training target rather than independently verified performance.

The independent scores: Artificial Analysis

Artificial Analysis evaluated both models using Intelligence Index v4.3 at maximum effort. The composite and component results are below.

Evaluation	Wonder Full	Wonder	Muse Spark 1.3	Notable comparison
Intelligence Index	56	52	48	Opus 5.5: 58; Sonnet 5.5: 56; Astra / Argon / Fable 5.1: 53; Grok 4.6: 44
Terminal-Bench 4.0	57%	52%	33%	Gemini 4 Argon: 57%
GDPval-AA	1857, #2	n/a	1681	Opus 5.5: 1866; Sonnet 5.5: 1838
AA-Briefcase	1729, #3	n/a	1581
CritPt	33%, #1	n/a	n/a	Nearest rivals: 31–32%
GDP.pdf	33%, #1	n/a	n/a	Nearest rivals: 31–32%
SciCode	63%, #3	n/a	n/a
AA-Omniscience	30	25	25	Opus 5.5: 46; Astra: 43; Argon: 42; Sonnet 5.5: 32
Hallucination rate	23%	27%	33%	Gemini 4 Argon: 15%
Coding Agents Index	68	63	54	Claude Code with Sonnet 5.5: 68; Opus 5.5: 66

Three conclusions stand out.

The jump from Muse Spark is real. Wonder Full gains eight points on the composite index in six weeks, and its Terminal-Bench score nearly doubles. Artificial Analysis described this as a material intelligence improvement over earlier Meta models.

Knowledge is the weak spot. Wonder Full scores 30 on AA-Omniscience versus 46 for Opus 5.5, indicating weaker factual recall. Its relatively low hallucination rate, however, means it is less likely to invent missing facts. For retrieval-heavy products, this points to grounding responses with search results or your own documents rather than relying on model recall.

Several leads are narrow. CritPt and GDP.pdf are only one to two points ahead of competing models. Wonder Full’s GDPval lead over Sonnet 5.5 is within confidence intervals. Its Coding Agents Index tie with Claude Code using Sonnet 5.5 is especially relevant for agent-runtime decisions, but that result belongs to Wonder Full, not the API-available Wonder model.

Where Meta and Artificial Analysis disagree

Meta’s model card lists Wonder Full at 59.0 on an Artificial Analysis Intelligence Index row, while Artificial Analysis publishes 56. The discrepancy may come from different index versions, run dates, or Meta’s evaluation harness. Neither party has publicly explained the gap.

When you see 59 quoted, it is Meta’s figure. When you see 56, it is the independent Artificial Analysis result. AutomationBench shows a similar issue: Meta reports 45.4 for Wonder Full and 39.1 for Wonder, while Artificial Analysis reports 71% and 68% on what appears to be a different version of the test. Always quote the source alongside the number.

Tokens and cost behind the scores

Maximum-effort scores come with a token cost. Artificial Analysis measured about 54,000 output tokens per task for both Wonder models, compared with 62,000 for Gemini 4 Argon, 78,000 for Claude Fable 5.1, and 27,000 for GPT-6 Astra.

Input usage is higher still. Wonder used 7.69 million input tokens across the index, while Wonder Full used 6.44 million—two to seven times more than the OpenAI and Google models. As a result, Wonder’s measured cost per task was $4.52: lower than Opus 5.5 at $5.98, but higher than GPT-6 Astra at $3.26 despite Astra’s 2.5x higher list price.

The Muse Wonder pricing post breaks down what these numbers mean for a realistic workload.

What to test yourself

Benchmarks show where to investigate, not what to ship. If you care about the agentic strengths Meta claims, test your own long-running task: a 30-step refactor, a multi-document review, or a tool loop with deliberate failures injected.

In Apidog, use the same prompts and tool definitions against Muse Wonder, Claude Opus 5.5, and your current model. Assert on the structured output and compare token usage for every run.

A useful evaluation record might look like this:

{
  "model": "muse-wonder-1.0",
  "task": "30-step-refactor",
  "passed": true,
  "tool_calls": 31,
  "recovered_from_errors": 3,
  "usage": {
    "input_tokens": 184320,
    "output_tokens": 51240
  }
}

Run enough iterations to see variance, then compare success rate, recovery behavior, structured-output reliability, and total token usage—not just a single passing response.

The tool-call test harness and the non-deterministic agent testing guide cover the setup in detail. You can also download Apidog to compare the models side by side.

Remember that the public API serves Muse Wonder, not Muse Wonder Full. Many benchmark headlines about Meta’s frontier result may describe the model you cannot currently call.

Frequently asked questions

Is Muse Wonder the best model available?

Not on the independent composite. Claude Opus 5.5 scores 58, Wonder Full scores 56, and Wonder scores 52. Wonder Full does lead several specific agentic benchmarks, including SWE-Marathon, DeepSWE, Harvey LAB, and FocusBench.

Which benchmarks can I trust?

Artificial Analysis results are third-party and reproducible. Meta’s cross-model table is Meta-run and uses best-effort competitor settings. MemoryBench, FocusBench, and the Personal Superintelligence Index are currently Meta-only.

How does Muse Wonder compare with Gemini 4 Argon?

Gemini 4 Argon scores 53 on the index versus 52 for Wonder, at half the price. Argon ties Wonder Full on Terminal-Bench at 57% and has a lower hallucination rate: 15% versus 27% for Wonder. The Gemini 4 Argon benchmarks post includes the full comparison.

Does maximum effort turn Muse Wonder into Muse Wonder Full?

No. Effort changes how long the model reasons. It does not turn muse-wonder-1.0 into Muse Wonder Full.

Next step

Choose the benchmark closest to your actual workload. Use SWE-Marathon for long coding runs or AA-Omniscience for factual recall, then run your own task before deciding whether Muse Wonder deserves a trial. The composite index alone will not answer that question.