Brave Search API: Pricing, API Key, Rate Limits and Fresh Twitter (X) Posts

By TwitterAPI.io Team•16 min read
Diagram: an agent question routed either to the Brave Search API web search endpoint for docs and articles or to the TwitterAPI.io advanced_search endpoint for X posts
Brave for the open web, an X search for posts. Brave prices from brave.com/search/api; X-side figures collected in 2026.
TL;DR
  • What it is: Brave's independent web index over REST. GET https://api.search.brave.com/res/v1/web/search with header X-Subscription-Token; an LLM Context endpoint (https://api.search.brave.com/res/v1/llm/context) returns pre-extracted page text for models.
  • Pricing: Search plan $5 per 1,000 requests (50 requests per second); Answers $4 per 1,000 requests + $5 per million input and output tokens (2 per second); Spellcheck and Autosuggest $5 per 10,000 requests; Enterprise on request.
  • Free use: $5 of credits every month on each plan, applied automatically; prepaid credits, no subscription; a credit card is required to activate a plan. Only successful requests are counted and billed.
  • Key and limits: create the key under API Keys in the Brave dashboard. Limits run on a 1-second sliding window; over the limit you get 429, and every response carries X-RateLimit-Limit, -Remaining and -Reset.
  • Measured on X: posts about the Brave Search API itself are quiet (97 posts in 30 days), but busy AI topics filled 200 posts in 20 to 96 minutes, newest under 1 minute old, and 80.8% carried no outbound link.
  • Pair it with an X search: /twitter/tweet/advanced_search pages through posts newest first at $0.15 per 1,000 posts returned; X's own pay-per-usage rate card lists $5 per 1,000 post reads.

This page is a working reference for the Brave Search API: the plans and per-request prices exactly as Brave publishes them, how to get a key in the dashboard, the endpoints worth knowing, how the rate-limit headers work, a Python call you can paste, and the MCP server for agents. Our Tavily API guide covers a different search API with credit-based billing; we link to it rather than repeat it, and the comparison table below only lists the dimensions that matter when you pick between them.

Every Brave price, limit and parameter below was read from Brave's own pricing page, developer docs and the official MCP server repository this year; the sources are listed at the end. We did not call the Brave API for this page. What we did measure is the other half of a common agent question, 'what are people saying about this right now': how fast posts arrive on X for search-API topics and busy AI topics, and how X developers talk about the Brave Search API itself. That data is ours, collected with a direct X search, and it decides when an agent should call Brave and when it should call something else.

X posts on busy AI topics with no outbound link

80.8%

01 — Section

What the Brave Search API is and which endpoints it has

The Brave Search API exposes the same index that powers Brave Search. Brave's FAQ on the API page says every result comes from Brave's own crawler and ranking, with no fallback to Google or Bing, and that the index is shaped by privacy-preserving signals from users who opt in to its Web Discovery Project. For builders this matters mostly because it is one of the few general web indexes you can query without going through Google or Microsoft: Brave's own page notes that Microsoft retired the Bing Search APIs and that Google closed its Custom Search API to new customers.

EndpointWhat it returnsPlan
GET https://api.search.brave.com/res/v1/web/searchRanked web results (title, URL, description, page age) plus news, videos, discussions, FAQ and other blocksSearch
GET https://api.search.brave.com/res/v1/llm/contextPre-extracted page text (grounding.generic[].snippets) and a sources map, sized for a modelSearch
News, images, videosDedicated verticals of the same indexSearch
AnswersA generated answer grounded on one or more searches, with citations, streaming and OpenAI SDK compatibilityAnswers
Spellcheck, AutosuggestQuery correction and completion as users typeSpellcheck, Autosuggest

Web search parameters that matter most. q is required (up to 600 characters and 75 words). count returns 1 to 20 web results (default 20) and offset skips whole pages of count, from 0 to 9, so one query can reach at most 200 web results. freshness filters by page age: pd (24 hours), pw (7 days), pm (31 days), py (365 days) or a custom YYYY-MM-DDtoYYYY-MM-DD range. result_filter limits the blocks returned (web, news, discussions, videos, faq, infobox, locations and others), extra_snippets adds up to 5 alternative excerpts per result, and country, search_lang and safesearch localize and filter.

Search operators. Brave's search-operator docs support site: (including subdomains, for example site:blog.example.com), exclusions such as NOT site:brave.com, and quoted phrases. Goggles let you re-rank or filter results with your own rules, which is listed as a Search-plan feature.

LLM Context vs web search. The quickstart now leads with LLM Context, described as 'Search for AI agents': instead of titles and short descriptions you get extracted, ranked text chunks per source, ready to drop into a prompt. Web search is the better fit when you render results for people or need the full result blocks. Brave's quickstart states that the Search plan includes both.

02 — Section

Brave Search API pricing: plans, free credits and what a request costs

Brave sells prepaid credits, not subscriptions. Its pricing docs list four self-serve plans plus Enterprise; currency and units below are exactly as Brave shows them.

PlanPriceFree monthly creditCapacity
Search (web, LLM Context, news, videos, images)$5.00 per 1,000 requests$550 requests per second
Answers$4.00 per 1,000 queries + $5.00 per 1M input tokens + $5.00 per 1M output tokens$52 requests per second
Spellcheck$5.00 per 10,000 requests$5100 requests per second
Autosuggest$5.00 per 10,000 requests$5100 requests per second
EnterpriseContact sales-Custom; full-funnel Zero Data Retention, NDAs, invoicing

Per-request math. One web search or LLM Context request costs $0.005 on the Search plan and returns up to 20 web results. The $5 monthly credit therefore covers 1,000 Search requests a month. An Answers query costs $0.004 plus tokens: a query that uses 3,000 input and 500 output tokens adds $0.0175, so about $0.0215 in total. The banner at the top of brave.com/search/api says 'Up to $20 in free calls every month', which matches four plans with a $5 credit each; on any single plan the credit is $5.

What is billed. Brave's rate-limit guide says only successful (non-error) requests are counted against your quota and billed, and the quota header carries a monthly window as well as the per-second one. Brave's FAQ explains the card requirement as abuse prevention: you are only charged for credits you choose to buy.

Storage and training rights. Brave's FAQ says storing results or using them to train models requires a plan that includes storage rights. If your agent caches results in a database or you plan to fine-tune on them, check that with Brave before you build the pipeline around it.

Brave's own benchmark claim. Brave's API page shows a FreshQA chart from its own published runs: 85.3% accuracy at $18 per 1,000 questions (search plus model tokens), against $49 to $89 for Parallel, Exa and Tavily. That is a vendor benchmark, so treat it as a starting point and run your own questions.

03 — Section

How to get a Brave Search API key, and the rate limits that come with it

Step 1: create an account. Go to the Brave Search API dashboard at api-dashboard.search.brave.com, sign up with an email and password, and confirm the email. Account creation is free.

Step 2: activate a plan. Open Plans in the dashboard, pick Search (or Answers), and enter a credit card. Brave's quickstart lists the card as a prerequisite; the free $5 monthly credit is applied automatically once the plan is active.

Step 3: create the key. In API Keys, click Add API Key, give it a descriptive name such as 'Production App' or 'Development', and copy it. Brave's docs ask you to treat it like a password: never commit it or ship it in client-side code. Separate keys per environment make it easy to revoke one without touching the other.

Step 4: send it on every request. Put the key in the X-Subscription-Token header (not Authorization, and not a query parameter), and send Accept: application/json plus Accept-Encoding: gzip as in Brave's samples. The dashboard also shows usage, which is the quickest way to see how fast the monthly credit is going.

Rate limits. Brave enforces limits on a 1-second sliding window: the count is evaluated over the most recent second, and a request is counted when it arrives, regardless of how long it takes to process. Exceed it and the API answers 429 and the request fails. The per-plan ceilings are the capacities above: 50 requests per second on Search, 2 on Answers, 100 on Spellcheck and Autosuggest.

HeaderExample from Brave's docsMeaning
X-RateLimit-Limit1, 15000Per-second limit, then monthly quota (0 means unlimited)
X-RateLimit-Policy1;w=1, 15000;w=2592000The same limits with window sizes in seconds (2,592,000 s = 30 days)
X-RateLimit-Remaining0, 14523Requests left in this second and this month
X-RateLimit-Reset1, 1234567Seconds until each window resets

Handle 429 properly. Brave's guide recommends reading X-RateLimit-Reset, backing off exponentially (1 s, 2 s, 4 s) and spreading requests evenly across the second instead of bursting. An agent that fans out ten searches in parallel on the Answers plan (2 per second) will see 429s on most of them; queue them instead.

Track both windows. Most plans carry a burst limit and a quota at the same time, so log the second number of X-RateLimit-Remaining too. It is the early warning that a loop is burning the month's credits.

python
# pip install requests
import os, requests

BRAVE = "https://api.search.brave.com/res/v1/web/search"
HEADERS = {
    "Accept": "application/json",
    "Accept-Encoding": "gzip",
    "X-Subscription-Token": os.environ["BRAVE_API_KEY"],
}

def brave_web(q: str, count: int = 10, offset: int = 0, freshness: str | None = None) -> list[dict]:
    params = {"q": q, "count": count, "offset": offset}
    if freshness:                      # pd, pw, pm, py or YYYY-MM-DDtoYYYY-MM-DD
        params["freshness"] = freshness
    r = requests.get(BRAVE, headers=HEADERS, params=params, timeout=30)
    if r.status_code == 429:           # 1-second sliding window exceeded
        raise RuntimeError("rate limited, reset in " + r.headers.get("X-RateLimit-Reset", "?") + " s")
    r.raise_for_status()
    body = r.json()
    return [
        {"title": x["title"], "url": x["url"], "snippet": x.get("description", ""), "age": x.get("page_age")}
        for x in body.get("web", {}).get("results", [])
    ]

for hit in brave_web("Model Context Protocol specification", count=5, freshness="pm"):
    print(hit["age"], hit["title"], hit["url"])
04 — Section

Brave maintains an official MCP server, @brave/brave-search-mcp-server on npm (version 2.1.4, released in September 2026, per the GitHub release list). It exposes brave_web_search, brave_local_search, brave_place_search, brave_image_search, brave_video_search, brave_news_search, brave_summarizer and brave_llm_context as tools. It reads the key from BRAVE_API_KEY (or a file path in BRAVE_API_KEY_FILE), and BRAVE_MCP_ENABLED_TOOLS / BRAVE_MCP_DISABLED_TOOLS let you expose only the tools you want the model to see.

Transport changed in version 2. The README notes that the server now defaults to STDIO; to keep HTTP you set BRAVE_MCP_TRANSPORT=http or pass --transport http. Version 2 also stopped returning base64 image data from brave_image_search, which had slowed responses and filled the context window. If an older config of yours points at an HTTP URL and suddenly fails, this is the first thing to check.

Add X next to it. Web search tools see the web; they do not page through what is being posted on X. TwitterAPI.io runs a hosted MCP server at mcp.twitterapi.io/mcp with read tools for tweet search, profiles, timelines, replies, followers and trends; you paste your TwitterAPI.io key as a Bearer token. With both configured, the model can choose Brave for documentation and articles and the X tools for posts. Our MCP server guide explains how MCP clients load and pick tools.

json
// Claude Desktop / Cursor style config: Brave for the web, TwitterAPI.io for X
{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@brave/brave-search-mcp-server", "--transport", "stdio"],
      "env": { "BRAVE_API_KEY": "YOUR_BRAVE_KEY" }
    },
    "twitterapi-io": {
      "url": "https://mcp.twitterapi.io/mcp",
      "headers": { "Authorization": "Bearer ${env:TWITTERAPI_IO_API_KEY}" }
    }
  }
}

# Claude Code, same two servers from the terminal
claude mcp add brave-search --env BRAVE_API_KEY=YOUR_BRAVE_KEY -- npx -y @brave/brave-search-mcp-server --transport stdio
claude mcp add --transport http --scope user twitterapi-io https://mcp.twitterapi.io/mcp \
  --header "Authorization: Bearer your_key_here"
05 — Section

What X developers say about the Brave Search API

To see how builders actually discuss it, we searched X for two sets of posts over the last 30 days: the exact phrases ('brave search api', 'brave search mcp', 'brave api key') and the broader 'brave search' together with api, mcp, agent or llm. After removing duplicates that left 97 posts from 69 accounts, about 3.2 a day. The narrow exact-phrase query alone found 49.

Mentioned alongside Brave Search APIShare of posts
Perplexity32.0%
Exa28.9%
Tavily27.8%
Firecrawl19.6%
Serper or SerpAPI14.4%
OpenAI or ChatGPT28.9%
n8n21.6%
Cursor20.6%
Claude or Claude Code19.6%
MCP14.4%

It is discussed as one option among several. Close to a third of the posts also name Perplexity, Exa or Tavily, and 25.8% talk about price, free use, credits or plans, which fits the search data behind this page: 'brave search api pricing' and 'brave search api key' are the variants people look up. Workflow tools show up as often as models: n8n appears in 21.6% of posts and Cursor in 20.6%.

What the sample cannot show. 97 posts is a small, public slice; it says nothing about how many teams use the API quietly, and keyword matching counts a name whether the post praises or criticizes it. Shares overlap because one post can name several tools.

Horizontal bar chart: share of 97 X posts about the Brave Search API that also mention Perplexity, Exa, Tavily, OpenAI, n8n, Cursor, Claude, Firecrawl, MCP and other tools
97 de-duplicated X posts from 30 days, keyword co-mentions. Collected in 2026.
06 — Section

Why a web search API is the wrong tool for fresh X posts

A web index answers 'which pages are about this'. Many agent questions are really 'what are people posting about this right now', and the two diverge fast on busy topics. Brave's tightest freshness setting is pd, pages up to 24 hours old, and a custom range is set in whole dates; one query reaches at most 200 web results (count 20 times 10 offsets). To see what that window holds on X, we ran a direct X search (/twitter/tweet/advanced_search, Latest, last 24 hours, up to 10 pages per topic) for four search-API topics and four busy AI topics, a few minutes apart.

TopicPosts foundWindow coveredPosts per hourNo outbound link
OpenAI200 (cap)23 min52576.5%
Anthropic200 (cap)29 min40780.0%
Cursor200 (cap)96 min12580.5%
Gemini200 (cap)20 min59486.0%
Brave Search924 h0.444.4%
Tavily1824 h0.850.0%
Perplexity API / web search API0 / 124 hunder 0.1-

Busy topics move in minutes. On all four AI topics our 200-post cap filled in 20 to 96 minutes, and the newest post was under a minute old when the search ran. A filter that means 'the last 24 hours' covers dozens of times more conversation than the 200 posts we read, so anything that ranks a few pages from that window is a small sample by construction.

Most posts point nowhere else. 80.8% of the busy-topic posts carried no outbound link: the reaction, the complaint or the benchmark screenshot lives only on X. A web index can surface an X post page at most; it has no article elsewhere to rank in its place.

Quiet topics are different. The search-API topics produced 28 posts in the whole day across four queries. For questions like 'is there a Brave Search API MCP server', the docs and articles Brave returns are the right answer and X adds little.

What the sample cannot show. We did not call the Brave API, so this is not a measurement of Brave's coverage of x.com; it measures how much X conversation exists inside the windows a web search can filter on. Eight topics at one moment are a snapshot, and post rates change by hour and news cycle.

Log-scale bar chart of X posts per hour for eight topics: Gemini, OpenAI, Anthropic and Cursor at 125 to 594 posts per hour, Tavily and Brave Search under one per hour
Last 24 hours, advanced_search Latest, up to 10 pages per topic. Collected in 2026.
07 — Section

Pair Brave with an X search: code and the X data bill

The fix is not a better web query; it is a second tool. TwitterAPI.io's GET /twitter/tweet/advanced_search takes X search operators (from:, quoted phrases, OR, -filter:replies, and since_time: / until_time: as Unix timestamps), returns up to 20 posts per page in tweets[] newest first with queryType=Latest, and pages with has_next_page and next_cursor. Each post carries createdAt, lang, likeCount, retweetCount, replyCount, viewCount, entities and the author object. Reads need no X account.

DimensionBrave Search API (Search plan)TwitterAPI.io advanced_searchOfficial X API (pay-per-usage)
Unit billedPer request: $5 per 1,000Per post returned: $0.15 per 1,000 postsPer post read: $5 per 1,000
One full page$0.005 for up to 20 web results$0.003 for 20 posts$0.10 for 20 posts
Freshness controlpd = last 24 hours, or whole datessince_time: to the secondStart and end times
Depth per queryUp to 200 results (offset 0-9)Cursor paging until the window endsPagination tokens; 3M post reads a month cap

Cost of our study. 972 posts over 57 requests came to 14,670 credits, $0.15. Tweet endpoints are billed 15 credits per post returned, $0.15 per 1,000 posts, with a 15-credit minimum per request (an empty page costs $0.00015; a full 20-post page costs $0.003). The same 972 post reads at $0.005 each on X's pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) would be $4.86: $5 against $0.15 per 1,000 posts, about 33x. X caps pay-per-usage at 3 million post reads a month and offers $20 of credits on a first card purchase plus a match of the first auto-recharge up to $50.

Getting started. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). Before the first payment the rate limit is 0.2 requests per second; it rises to 20 once paid. Plans and credit packs are on the pricing page; purchased credits never expire.

python
import os, time, requests

BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]}

def x_posts(topic: str, minutes: int = 60, max_pages: int = 10) -> list[dict]:
    since = int(time.time()) - minutes * 60
    params = {"query": f"{topic} since_time:{since}", "queryType": "Latest", "cursor": ""}
    posts = []
    for _ in range(max_pages):
        r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        body = r.json()
        posts += body.get("tweets", [])
        if not body.get("has_next_page"):
            break
        params["cursor"] = body["next_cursor"]
    return posts

posts = x_posts("Gemini", minutes=30)
print(len(posts), "posts in the last 30 minutes; newest:", posts[0]["createdAt"] if posts else None)
08 — Section

Which question goes to Brave, which to X, and when to use both

Question typeFirst callWhy
Docs, specs, how-tos, company pagesBrave web search or LLM ContextIndependent index, extracted text for the model, $0.005 a request
News coverage of an eventBrave with result_filter=news and freshness=pdArticles with page age; one call, up to 20 results
'What are people saying on X right now?'X search (advanced_search, Latest)Posts minutes old; pages past 20 results
One account's latest postsX timeline (/twitter/user/last_tweets)Exact account, newest first
An event plus public reactionBothBrave for the articles, X search for the posts

Where the tools differ from Tavily. Brave bills per request with a 24-hour finest freshness filter and up to 200 results via offset; Tavily bills in credits per search and caps a search at 20 results with no next page. Both are web tools first. Our Tavily API page measured what Tavily returns when asked for X posts directly; the same routing conclusion holds here.

Write the tool descriptions for routing. Agents choose tools by description, so say what each tool cannot do: 'web pages, documentation and news articles; not a live X feed' for Brave, and 'posts, replies and accounts on X (Twitter), newest first, any time window' for the X tool. Then log which tool the model picked for a week and adjust the wording.

Build it. Get a TwitterAPI.io key from the dashboard, check fields in the API reference at docs.twitterapi.io, and drop the router from the full example below into your agent next to your Brave key.

python
# LLM Context: pre-extracted page text for a model (included in the Search plan)
import os, requests

r = requests.get(
    "https://api.search.brave.com/res/v1/llm/context",
    headers={"Accept": "application/json", "X-Subscription-Token": os.environ["BRAVE_API_KEY"]},
    params={"q": "Model Context Protocol transports"},
    timeout=30,
)
r.raise_for_status()
body = r.json()
for g in (body.get("grounding", {}).get("generic") or [])[:3]:
    print(g["title"], g["url"])
    print(g["snippets"][0][:200] if g.get("snippets") else "")
09 — Section

How we collected this

Question. How do X developers talk about the Brave Search API, and how much X conversation sits inside the 24-hour window a web search can filter on, for quiet and busy topics?

Queries. Part 1: 'brave search api' OR 'brave search mcp' OR 'brave api key', and 'brave search' with api, mcp, agent, agents or llm, last 30 days, merged and de-duplicated. Part 2: 'Brave Search', Tavily, 'Perplexity API', 'web search API', OpenAI, Anthropic, Cursor and Gemini, each over the last 24 hours. All via /twitter/tweet/advanced_search with queryType=Latest, up to 10 pages per 24-hour topic.

Window and sample. Collected in 2026, all calls within a few minutes. 57 requests returned 972 posts (97 unique Brave-related posts, 828 posts across the eight 24-hour topics). Where the 200-post cap was hit, posts per hour is computed over the shorter span actually covered. Links count as outbound when they point outside x.com and twitter.com.

What it cannot show. The Brave API was not called, so nothing here measures Brave's index or its coverage of x.com. Keyword co-mentions do not capture sentiment, and one moment does not capture daily cycles.

Privacy. Aggregates only. No author is named or profiled; the de-identified sample carries no post ID, URL, text or handle, and raw search pages were not kept.

python
"""Route agent questions: X questions -> TwitterAPI.io advanced_search, everything else -> Brave Search API.

pip install requests
export BRAVE_API_KEY=...             # api-dashboard.search.brave.com (API Keys)
export TWITTERAPI_IO_API_KEY=...     # twitterapi.io/dashboard
"""
import os
import re
import time

import requests

X_BASE = "https://api.twitterapi.io"
X_HINTS = re.compile(r"(\bon x\b|twitter|tweets?|posts on x|@\w+|#\w+|reactions?)", re.I)


def brave_search(query: str, count: int = 10, freshness: str | None = None) -> list[dict]:
    params = {"q": query, "count": count}
    if freshness:
        params["freshness"] = freshness
    for attempt in range(4):
        r = requests.get(
            "https://api.search.brave.com/res/v1/web/search",
            headers={
                "Accept": "application/json",
                "Accept-Encoding": "gzip",
                "X-Subscription-Token": os.environ["BRAVE_API_KEY"],
            },
            params=params,
            timeout=30,
        )
        if r.status_code != 429:
            break
        time.sleep(2 ** attempt)  # Brave rate limits use a 1-second sliding window
    r.raise_for_status()
    print("brave remaining (per second, per month):", r.headers.get("X-RateLimit-Remaining"))
    return [
        {"title": x["title"], "url": x["url"], "snippet": x.get("description", ""), "age": x.get("page_age")}
        for x in r.json().get("web", {}).get("results", [])
    ]


def x_search(topic: str, hours: int = 24, max_pages: int = 5) -> list[dict]:
    since = int(time.time()) - hours * 3600
    params = {"query": f"{topic} since_time:{since}", "queryType": "Latest", "cursor": ""}
    out = []
    for _ in range(max_pages):
        r = requests.get(
            f"{X_BASE}/twitter/tweet/advanced_search",
            headers={"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]},
            params=params,
            timeout=30,
        )
        r.raise_for_status()
        body = r.json()
        for t in body.get("tweets", []):
            out.append({
                "createdAt": t["createdAt"],
                "author": t["author"]["userName"],
                "likes": t["likeCount"],
                "views": t.get("viewCount"),
                "text": t["text"],
                "url": t["url"],
            })
        if not body.get("has_next_page"):
            break
        params["cursor"] = body["next_cursor"]
    return out


def gather(question: str, topic: str) -> dict:
    if X_HINTS.search(question):
        posts = x_search(f'"{topic}"', hours=6)
        return {"route": "x", "count": len(posts), "items": posts}
    pages = brave_search(question, freshness="pw")
    return {"route": "web", "count": len(pages), "items": pages}


if __name__ == "__main__":
    for q, topic in [
        ("What are people posting on X about Gemini right now?", "Gemini"),
        ("Brave Search API rate limit headers documentation", "Brave Search API"),
    ]:
        res = gather(q, topic)
        print(res["route"], res["count"], res["items"][:1])

Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.

10 — Questions

Questions readers ask

Is the Brave Search API free?

Not fully. Each plan includes $5 of free credits every month, which is 1,000 requests on the Search plan at $5 per 1,000, but you must add a credit card to activate a plan. Usage beyond the credit is paid from prepaid credits you choose to buy.

How much does the Brave Search API cost per request?

On the Search plan, $5 per 1,000 requests, so $0.005 per web search or LLM Context request. Answers costs $4 per 1,000 queries plus $5 per million input tokens and $5 per million output tokens. Spellcheck and Autosuggest are $5 per 10,000 requests. Only successful requests are billed.

How do I get a Brave Search API key?

Sign up at api-dashboard.search.brave.com, activate a plan under Plans with a credit card, then open API Keys and click Add API Key. Send the key in the X-Subscription-Token header on every request.

What is the Brave Search API rate limit?

50 requests per second on Search, 2 on Answers and 100 on Spellcheck and Autosuggest, counted on a 1-second sliding window. Over the limit the API returns 429; the X-RateLimit-Remaining and X-RateLimit-Reset headers show what is left and when each window resets.

Does the Brave Search API have an MCP server?

Yes. Brave publishes @brave/brave-search-mcp-server on npm with web, local, place, image, video, news, summarizer and LLM Context tools. It defaults to STDIO since version 2 and reads BRAVE_API_KEY. You can run it next to TwitterAPI.io's hosted server at mcp.twitterapi.io/mcp for X data.

Can the Brave Search API return recent tweets?

It searches the web, so it can return x.com pages it has indexed, but its finest freshness filter is 24 hours and one query reaches at most 200 results. In our 2026 measurement busy AI topics produced 200 X posts in 20 to 96 minutes. For recent posts use an X search endpoint such as /twitter/tweet/advanced_search.

What is the difference between Brave web search and LLM Context?

Web search returns ranked results with titles, URLs, descriptions and blocks such as news and discussions, suited to search interfaces. LLM Context returns extracted text snippets per source, sized to pass straight to a model. Both are included in the Search plan.

Can I store Brave Search API results or train on them?

Brave's FAQ says storing results or using them to train models requires a plan that includes storage rights. Check with Brave before caching results long term or building a training set from them.

11 — Further reading

Continue

Sources & further reading
More from this series

Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.

Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.