Warp Pricing in 2026: Plans, Dollar Usage, Add-ons and the Real Monthly Bill

By TwitterAPI.io Team•18 min read
Diagram of Warp pricing. Five plan cards: Free $0 with no included usage and purchases at $12 per $10, Build $20 a month ($18 annual) with $20 of usage at API rates, Max $200 ($180 annual) with $200 of usage, Business $50 per seat ($45 annual) with $20 of usage per seat and up to 25 seats, Enterprise custom. Each prompt or cloud run draws three components: inference at public API rates, compute for cloud sandboxes from $0.003 a minute, and platform time at $3 per agent hour.
How a Warp month is billed, from Warp's pricing page and billing docs.
TL;DR
  • Plans: Free $0, Build $20 monthly ($18 annual), Max $200 monthly ($180 annual), Business $50 per user/month ($45 annual, up to 25 seats), Enterprise custom.
  • Usage is dollars, not requests: Build includes $20 of agent usage at API rates, Max $200, Business $20 per seat. Included usage resets monthly with no rollover.
  • Running out: add-on usage is team-shared and valid 12 months; Free pays a 20% premium ($12 for $10 of usage) and cannot auto-reload. Auto-reload has a $200 default team limit.
  • Your own key: BYOK, ChatGPT or SuperGrok subscriptions and custom endpoints skip Warp's inference bill on every plan, for individuals and organizations with 10 or fewer employees.
  • What X says: of 275 posts about Warp pricing (collected in 2026), bring-your-own-key went from 2.6% before the Build plan to 29.5% after it, while posts naming a plan fell from 34.0% to 10.7%.
  • X data in Warp: add our MCP server to .warp/.mcp.json; X reads cost $0.15 per 1,000 tweets returned vs $5.00 at the official X API's $0.005 per post read.

Warp started as a Rust terminal and now calls itself an agentic development environment: a terminal with a built-in coding agent, a Warp Agent CLI for any shell, cloud agents and a separate product, Warp Factories, for fleets of agents. Its pricing has changed several times since 2025, and most write-ups still describe credits or request counts that no longer appear on the plan cards. This page is built from warp.dev/pricing and Warp's plans-and-billing docs as read this session, with the arithmetic that turns those terms into a monthly bill.

We also pulled 275 X posts that pair Warp with pricing terms, and the latest 160 posts from @warpdotdev, to see what people actually say about Warp's price and how that changed when the Build plan replaced the old tiers. The last sections show how to wire X (Twitter) data into Warp's agent through MCP, with the data bill priced out.

If you are weighing Warp against other agents, our Claude Code pricing and Codex pricing pages cover those subscriptions in the same detail, and our Claude Code alternatives page compares the tools side by side. This page stays on Warp's own pricing mechanics.

Share of X posts about Warp pricing that mention bringing your own API key, before and after the Build plan

2.6% before, 29.5% after, across 275 X posts (collected in 2026); posts naming a plan fell from 34.0% to 10.7%.

01 — Section

Warp plans and prices at a glance

Prices below are copied from warp.dev/pricing for the Warp Terminal plans, in US dollars. The annual price is the per-month rate when billed yearly.

PlanMonthlyAnnual (per month)Included agent usageSeats
Free$0$0None (pay as you go)Up to 10
Build$20$18$20 a month at API ratesUp to 10
Max$200$180$200 monthly (10x Build)Up to 10
Business$50 per user$45 per user$20 per seat a monthUp to 25
EnterpriseCustomCustomCustom shared poolsUnlimited

Seat caps. Business shows "up to 25 seats" on its card. The 10-seat caps for Free, Build and Max come from the plan comparison data on the same page; Warp introduced per-plan seat limits on May 21, 2026, and teams already above a cap keep their members but cannot add new ones.

What Free includes. The modern terminal, the Warp Agent CLI, MCP support, limited cloud agents, 30 cloud-stored conversations, 3 indexed codebases of up to 3,000 files, and limited Warp Drive sharing (10 workflows, 3 notebooks). Free has no bundled agent usage: to use Warp-provided models you buy usage, upgrade, or bring your own inference.

What Build adds. $20 of usage at API rates, full Warp Agent access to frontier and open-source models (the page lists Fable 5, Claude Opus 5, GPT-5.6, Gemini 3.1 Pro, GLM 5.2 and Kimi K3), add-on usage with auto-reload and a team-wide spend cap, 40 indexed codebases of up to 100,000 files, unlimited Warp Drive objects and conversation storage, and private email support. Max is Build with ten times the included usage.

What Business adds. SAML-based SSO, team usage metrics, admin-configurable data controls and bring-your-own keys and endpoints for organizations of any size. Enterprise adds unlimited seats, custom usage pools, BYOLLM through AWS Bedrock or Google Vertex AI, self-hosted cloud agents and a dedicated account manager.

No discounts. Warp's pricing FAQ says it does not offer student, non-profit or open-source discounts. The client itself is open source under AGPL v3 (github.com/warpdotdev/warp), and payment is by card through Stripe.

02 — Section

How Warp bills agent usage: dollars at API rates

Warp's billing docs split every charge into three components, all drawn from the same usage balance:

ComponentWhat it pays forRate on Free, Build, Max, Business
InferenceModel calls Warp providesPublic API rates of the model (input, output, cache tokens, web search)
ComputeWarp-hosted cloud sandboxesLinux $0.0015 per unit-minute, Windows $0.003, macOS from $0.075 a minute
PlatformBillable agent time on cloud runs$3 per agent hour ($0.05 per billable minute)

Inference is the part most people pay. For paid self-serve plans billed in dollars, Warp-provided inference is priced at public API rates, so a prompt costs what its tokens cost on that model. Warp names the drivers: model choice, prompt and conversation size, attached context, caching, multi-step tasks and provider tools such as web search. Two similar prompts can cost different amounts. Expand the usage figure under any agent response to see input, output, cache-read and cache-write tokens and their cost; in the CLI, /cost shows the cost of each response.

Compute only applies in the cloud. Linux sandboxes cost the greater of the vCPU count and half the memory in GB, times $0.0015 a minute, so 4 vCPUs with 8 GB is $0.006 a minute ($0.36 an hour). Windows is twice that, and Apple Silicon macOS runners start at $0.075 a minute for 4 vCPUs and 7 GB. Metering runs from sandbox creation to destruction, including idle time, in proportional partial minutes. Local runs and self-hosted workers have no compute charge.

Platform usage is per agent hour. Cloud runs, including Warp Factories runs and third-party harnesses, are charged $3 per agent hour for billable activity; queued and idle time is excluded. For the Warp Agent, only time spent generating responses counts, not a five-minute test suite it runs; for Claude Code and Codex harnesses, active runtime counts. Local runs on Free, Build and Max never carry a platform charge.

A worked cloud run from Warp's docs. A 4 vCPU / 8 GB Linux sandbox alive for 10 minutes, with 6 billable agent minutes and $0.40 of inference, costs $0.06 of compute, $0.30 of platform and $0.40 of inference: $0.76 from the balance.

What is free. Regular shell commands and non-AI terminal features never consume usage. Generate and AI Autofill in Workflows do use inference. Running claude or codex yourself in a Warp tab is billed by those vendors, not by Warp.

Credits still exist, on contracts. Warp now shows usage in dollars; a credit is described as "a usage unit, not a token or a fixed number of prompts". Enterprise contracts that bill in credits keep their pools and rates, and old self-serve credit packs converted to dollars keep their face value or equivalent inference value, whichever is higher. The comparison data on the pricing page still carries an older row reading "$20 (1,500 credits)" for Build and "$240 (18,000 credits)" for Max, which is why credit figures keep showing up in third-party guides; the plan cards themselves list $20 and $200 of usage.

03 — Section

Buying more Warp usage: add-ons, auto-reload and spend limits

When included usage runs out, Warp draws from purchased usage; with none left, runs stop (cloud runs fail with an insufficient-credits error) until the monthly reset or a purchase. Purchased usage covers inference, compute and platform charges, rolls over across billing cycles and expires 12 months after purchase.

Free-plan prices are published. The purchase card on the pricing page sells usage without a subscription at four sizes:

You payUsage you getPremium
$12$10 of usage20%
$24$20 of usage20%
$60$50 of usage20%
$120$100 of usage20%

Paid-plan prices are shown in the app. Warp's FAQ says "Free plan prices are 20% higher than paid-plan prices", which puts paid-plan add-ons at about face value ($10 for $10 of usage); the docs send paid users to Settings > Billing and usage for the exact amounts. Our bill math below uses face value and labels it as an assumption.

Auto-reload and the spend limit. On paid plans an admin can turn on auto-reload, which buys the chosen amount when included usage is exhausted and the purchased balance runs low. It is off by default, and the Free purchase card only supports one-time buys. One-time purchases and reloads count toward a single team-wide monthly spend limit that defaults to $200; Warp warns that the limit is not a guaranteed ceiling once taxes and Free premiums are added, and that heavy use by any member can trigger repeated reloads.

Purchases belong to the team. New purchases go into a shared team balance, and any member draws on it after their own included usage. Any active member can make a one-time purchase on the team's saved card. Warp moved add-ons to per-user balances on May 21, 2026 and back to a team pool in August 2026, so leftover personal balances from that window are spent after the shared pool. Leave the team and you lose access to its balance; rejoin and unused, unexpired usage returns.

Resets and refunds. Included usage resets monthly even on annual plans (the pricing FAQ says every 30 days from the subscription or renewal date) and never rolls over. Monthly subscriptions are refundable within 24 hours and annual ones within 15 days, in both cases only if no usage was consumed; unused purchases are refundable until any of them is used.

04 — Section

Free, Build or Max: the monthly bill by usage

Because Build and Max include usage at the same API rates and add-ons are bought at about face value, the plans differ less than the $20 and $200 price tags suggest. The table prices a month of agent usage on each option, on list prices:

Agent usage in a monthFree (buy at +20%)Build monthlyBuild annualMax annual
$10$12.00$20.00$18.00$180.00
$20$24.00$20.00$18.00$180.00
$50$60.00$50.00$48.00$180.00
$100$120.00$100.00$98.00$180.00
$200$240.00$200.00$198.00$180.00
$300$360.00$300.00$298.00$280.00

Free beats Build only for light use. Buying usage at a 20% premium is the lower bill below $16.67 of usage a month, roughly the point where a $12 pack plus change matches the $20 subscription. Free purchases also last 12 months, so a few prompts a month can run for a year on a $12 pack. Above that, Build wins, and its add-ons cost about 17% less than Free's.

Monthly Max never costs less than Build plus add-ons. On these terms, Build plus add-ons equals Max at exactly $200 of usage, and above $200 both bill at face value, so the totals match. Max monthly is a convenience: one predictable charge instead of reloads.

Annual Max is the exception. At $180 a month, annual Max is the lower bill above $182 of usage and saves $18 a month against annual Build at $200 or more. Anyone reliably spending $200 monthly on agent usage is $216 a year better off on annual Max.

BYOK changes the math. Bring your own key and Warp's inference bill drops to zero on Free, Build and Max for local runs: you pay the model provider directly at its own rates, and Warp bills only the subscription (if any) plus cloud charges. The chart puts the three plans on one axis; swap in your own usage in the script.

python
# warp_bill.py - what a month of Warp agent usage costs on each plan (list prices, warp.dev/pricing)
FREE_PREMIUM = 1.2     # Free buys $10 of usage for $12
PAID_ADDON = 1.0       # assumption: paid-plan add-ons at face value (Free is "20% higher than paid-plan prices")
PLANS = {              # (fee per month, included usage in dollars)
    "Build monthly": (20, 20), "Build annual": (18, 20),
    "Max monthly": (200, 200), "Max annual": (180, 200),
}


def bills(usage):
    out = {"Free": round(usage * FREE_PREMIUM, 2)}
    for name, (fee, included) in PLANS.items():
        out[name] = round(fee + max(0, usage - included) * PAID_ADDON, 2)
    return out


if __name__ == "__main__":
    for usage in (10, 20, 50, 150, 250):
        b = bills(usage)
        best = min(b, key=b.get)
        print(f"${usage} of usage: " + ", ".join(f"{k} ${v:,.2f}" for k, v in b.items()) + f"  -> {best}")
Line chart of the monthly Warp bill against agent usage from $0 to $400: Free pay-as-you-go at 1.2 times usage, Build monthly flat at $20 then rising one-for-one, Max monthly flat at $200 then rising, Max annual flat at $180. Free beats Build below $16.67, Build plus add-ons equals Max at $200, and annual Max wins above $182.
Monthly Warp bill by agent usage, on list prices from warp.dev/pricing; paid-plan add-ons assumed at face value.
05 — Section

Bring your own key, subscriptions and custom endpoints

Since May 21, 2026, every Warp plan, Free included, can run the Warp Agent on inference you pay for yourself. Requests routed this way do not consume Warp-provided usage:

Your own API key. Add an OpenAI, Anthropic or Google key under Settings > Agents > Warp Agent > Manage models (or /api-keys in the CLI). The key is stored on your device and the provider bills you directly.

A subscription you already pay for. Warp can run eligible OpenAI models through a ChatGPT subscription for local conversations, and Grok models through a SuperGrok subscription.

A custom inference endpoint. Any OpenAI-compatible URL, such as OpenRouter, LiteLLM, z.ai or a gateway your team runs, configured in the Warp app.

The size rule. Self-serve BYOK, subscriptions and custom endpoints are for individuals and organizations with 10 or fewer employees, under Warp's Terms of Service. Companies with more than 10 employees need Business or Enterprise to use them.

Where BYOK still costs something. On Business and Enterprise, local runs that use your own inference are charged platform usage at $3 per agent hour; on Free, Build and Max they are not. Cloud runs carry platform charges whoever pays for inference. Zero Data Retention agreements cover Warp-provided inference only; with your own key, requests go to your provider under your own terms.

Enterprise BYOLLM. Enterprise can route inference through models hosted in its own AWS Bedrock or Google Vertex AI account, with Azure AI Foundry listed as coming soon; inference is billed in that cloud account, not through Warp.

06 — Section

How Warp pricing changed: from Pro, Turbo and Lightspeed to dollar usage

Much of what you read about Warp pricing describes plans that are gone. The milestones, from Warp's own blog and docs:

WhenChange
October 30, 2025Build announced at $20 a month with 1,500 credits; Pro, Turbo and Lightspeed deprecated; Business repriced to $50 per user
December 1, 2025Existing Pro, Turbo, Lightspeed and Business subscribers move to the new plans at their first renewal after this date
May 21, 2026Per-plan seat limits, BYOK on every plan including Free, custom inference endpoints, platform metering for cloud agent runs
August 2026Add-on usage pooled across the team again, after a May to August spell of per-user balances
NowPlan cards state included usage in dollars at API rates; Max lists $200 of usage (10x Build)

Why Warp changed. Zach Lloyd's October 30, 2025 post argued that many users did not use the credits they paid for, that legacy plan credits were much cheaper than overages, and that "At full usage, the plans didn't scale sustainably". It said plainly that the new plan "will be more expensive for some users and less expensive for others", and it gave Turbo and Lightspeed users auto-reload up to $50 and $225 to soften the move.

What the old tiers looked like. Warp's announcement does not list the legacy prices. Posts in our X sample quote them often: Turbo at $50 a month for 10,000 requests is the most common description, with Pro at $15 and a $200 Lightspeed tier. Treat those as what users reported, not as Warp's published terms.

We could not date the switch to dollars. Warp's own pages show the dollar wording but not the day it replaced credit counts; third-party trackers place it in autumn 2026. Check Settings > Billing and usage for what your own account shows, since existing seats can have a different allowance from new subscriptions.

07 — Section

What people on X say about Warp pricing

We searched X for posts that pair Warp with pricing words (pricing, price, credits, plan, subscription, BYOK, $20, $200, Lightspeed, Turbo) and kept 275 posts from 193 accounts after removing the official account, reposts, funding news and other meanings of "warp". 175 are from 2025 and 92 from 2026; 57.1% are replies, often to @warpdotdev itself.

The conversation moved from tiers to keys. Before the Build plan, 34.0% of posts named a plan and 29.4% named Pro, Turbo or Lightspeed. Since then, plan names appear in 10.7%, and bring-your-own-key is the biggest topic at 29.5%, up from 2.6%. Credits stayed steady (28.1% before, 30.3% after), and open source rose from 1.3% to 7.4%.

What the post mentionsBefore BuildSince BuildAll posts
Bring your own key / API key2.6%29.5%40
Credits28.1%30.3%80
Names a plan or tier34.0%10.7%65
Limits, running out, burning credits15.7%6.6%32
Free tier, promo codes, invites11.1%5.7%24
Calls it expensive5.2%2.5%11
Cancel or switch5.2%4.1%13

Complaints about limits faded. Posts about limits, running out or burning credits fell from 15.7% to 6.6%, which fits a model where a heavy user can keep buying usage instead of hitting a request cap. Few posts judge the price at all: 11 call Warp expensive and 4 call it cheap or worth it.

$50 is still the price people quote. "$50" appears in 16 posts, mostly the old Turbo tier, against 15 for "$20", 10 for "$200" and 7 for "$15".

Warp is priced against other agents. 29.1% of the posts name another coding tool: Claude Code 17.1%, Cursor 15.3%, Codex 4.4% and Gemini CLI 3.3%. Several compare Warp's included usage with the limits on Claude's or Cursor's subscriptions.

Engagement is modest and English-heavy. 96.7% of the posts are in English. Median likes are 3 (p90 36) and median views 322 (p90 4,779).

The official account rarely talks price, and it works when it does. Of 56 original posts among the latest 160 from @warpdotdev (59,513 followers), 7 (12.5%) are about pricing, usage, plans or BYOK. Those earned a median 61 likes and 7,694 views, against 29 likes and 5,520 views for its other original posts.

Dumbbell chart of topic shares in X posts about Warp pricing, before and after the Build plan: bring your own key 2.6% to 29.5%, credits 28.1% to 30.3%, names a plan 34.0% to 10.7%, legacy Pro, Turbo or Lightspeed 29.4% to 5.7%, limits or running out 15.7% to 6.6%, open source 1.3% to 7.4%.
Share of 275 X posts about Warp pricing that mention each topic, before (153) and after (122) the Build plan; keyword-matched. Collected in 2026.
08 — Section

Adding X (Twitter) data to Warp, and what it costs

Warp's agent is an MCP client in the app, the CLI and the cloud, and it accepts remote servers over Streamable HTTP with custom headers. Save the block below as ~/.warp/.mcp.json for every project or .warp/.mcp.json at a repo root; Warp detects file-based servers and spawns them automatically, or you can paste the same JSON under Settings > Agents > MCP servers. The TwitterAPI.io hosted server is https://mcp.twitterapi.io/mcp with your API key as a Bearer token. Keep the file out of version control, since it holds the key.

Two separate bills. The agent work Warp does to call the tool and read the result is billed as Warp usage (or by your own provider with BYOK). The X data is billed by TwitterAPI.io: 15 credits per tweet returned, which is $0.15 per 1,000 tweets, and 18 credits per profile ($0.18 per 1,000). A request that returns nothing still costs the 15-credit minimum ($0.00015), and a full 20-tweet page costs $0.003. $1 buys 100,000 credits, and purchased credits never expire.

JobTwitterAPI.ioOfficial X API (pay-per-usage)
Read 1,000 tweets$0.15$5.00 ($0.005 per post read)
Read 1,000 profiles$0.18$10.00 ($0.010 per user read)
This page's study (843 tweets, 1 profile)about $0.13about $4.22 at the same rate card

Named rate card. The official prices come from the X API pay-per-usage card at docs.x.com/x-api/getting-started/pricing: $0.005 per post read and $0.010 per user read, capped at 3 million post reads a month before Enterprise. Per 1,000 tweets that is $5.00 against $0.15, about 33x. New TwitterAPI.io 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). Reads need no X account.

A useful first prompt. Ask the agent to "search X for the last day of posts about our product and group them by complaint", and it will page through /twitter/tweet/advanced_search results with real fields such as likeCount, viewCount and author.followers. A cloud agent on a schedule can do the same nightly; remember that cloud runs add Warp compute and platform charges on top of the X data. The Python script in this page's code block is the plain REST version: it watches @warpdotdev and X search for the next Warp pricing change.

Posting from an agent. Writes are available too: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each post, like, follow or retweet through /twitter/create_tweet_v2 and its siblings is 60 credits ($0.0006), billed per HTTP 200 call. The call acts as that account, so X can rate-limit, lock or suspend it; keep a human pace, and expect the session to need a re-login from time to time.

json
{
  "mcpServers": {
    "twitterapi-io": {
      "url": "https://mcp.twitterapi.io/mcp",
      "headers": { "Authorization": "Bearer your_key_here" }
    }
  }
}
09 — Section

How we collected this

Question. When people on X talk about Warp's pricing, what do they talk about: which plans, credits or dollar usage, running out, add-ons, bring-your-own-key, value judgments and which other tools, and did that change when the Build plan arrived? How much of the official @warpdotdev feed is about pricing?

Query and accounts. Search: (warpdotdev OR "warp terminal" OR "warp.dev" OR "warp agent" OR "warp ai") (pricing OR price OR credits OR credit OR plan OR subscription OR byok OR "$20" OR "$200" OR lightspeed OR turbo OR "build plan") -filter:retweets, Latest results until the search ran out (31 pages) plus 6 pages of Top results, deduplicated. We kept posts with a Warp reference, a pricing term and a coding context, and dropped the official account, reposts, funding news and other uses of "warp" (Cloudflare WARP, warp drives, time warps). Official account: @warpdotdev profile plus its latest 160 posts, replies included.

Window and sample. The search returned 683 tweets (589 unique); 275 were kept from 193 accounts, nearly all from 2025 and 2026, split at Warp's October 30, 2025 Build announcement into 153 earlier and 122 later posts. The official timeline covered about 91 days. 46 requests in total, 843 tweets and 1 profile returned, about $0.13 at our rates; collected in 2026.

Method. Topics were matched with case-insensitive regular expressions on post text; a post can count in several topics. The bill model is arithmetic on Warp's published prices (and one labeled assumption about paid add-on rates), not X data. Scripts and results are in our repository under data/studies/warp-pricing/.

What the sample cannot show. Keyword matching misses sarcasm and posts that describe a price without the exact words, and the search returns a sample of X, not every post. Posts do not measure how many people pay for Warp or what they spend; prices quoted in posts are users' reports, not Warp's terms. The before and after split is by post date, so some later posts still discuss old plans.

Privacy. Aggregates only. Search authors are private individuals: their raw posts were not stored in the repository, and the de-identified sample keeps only language, year, counts, topic flags and a follower bucket (no ids, URLs, text or handles). Only the organization account @warpdotdev is named.

python
"""warp_pricing_watch.py - follow Warp (warp.dev) pricing news on X (Twitter).

Reads the latest @warpdotdev posts and a pricing search, and prints the ones that
mention plans, usage, credits or bring-your-own-key, newest first.
pip install requests
export TWITTERAPI_IO_API_KEY=...   # from the twitterapi.io dashboard
"""
import os
import re

import requests

API_KEY = os.environ["TWITTERAPI_IO_API_KEY"]
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": API_KEY}
PRICING = re.compile(r"pric|credit|usage|byok|own (api )?key|\$\d|plan|reload|billing", re.I)
MAX_PAGES = 3  # a full page holds up to 20 tweets (15 credits per tweet returned)


def official_posts(user="warpdotdev"):
    """Latest posts from the official account; last_tweets nests tweets under data."""
    tweets, cursor = [], None
    for _ in range(MAX_PAGES):
        params = {"userName": user}
        if cursor:
            params["cursor"] = cursor
        r = requests.get(f"{BASE}/twitter/user/last_tweets", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        body = r.json()
        tweets += (body.get("data") or {}).get("tweets", [])
        if not body.get("has_next_page"):
            break
        cursor = body.get("next_cursor")
    return tweets


def search(query):
    """advanced_search returns tweets at the top level."""
    tweets, cursor = [], None
    for _ in range(MAX_PAGES):
        params = {"query": query, "queryType": "Latest"}
        if cursor:
            params["cursor"] = cursor
        r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        body = r.json()
        tweets += body.get("tweets", [])
        if not body.get("has_next_page"):
            break
        cursor = body.get("next_cursor")
    return tweets


def show(label, tweets):
    hits = [t for t in tweets if PRICING.search(t.get("text") or "")]
    print(f"\n== {label}: {len(hits)} of {len(tweets)} posts mention pricing")
    for t in hits[:15]:
        author = (t.get("author") or {}).get("userName")
        print(f"{t['createdAt']}  @{author}  likes={t.get('likeCount', 0)} views={t.get('viewCount', 0)}")
        print("   ", (t.get("text") or "").replace("\n", " ")[:200])
        print("   ", t.get("url"))


if __name__ == "__main__":
    show("@warpdotdev", official_posts())
    show("search", search('(warpdotdev OR "warp terminal") (pricing OR credits OR byok OR "build plan") -filter:retweets'))

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

10 — Questions

Questions readers ask

How much does Warp cost?

Warp Free is $0. Build is $20 a month ($18 billed annually) with $20 of agent usage, Max is $200 monthly ($180 annually) with $200 of usage, Business is $50 per user a month ($45 annually) with $20 of usage per seat and up to 25 seats, and Enterprise is custom. Extra usage is bought as add-ons.

Is Warp free?

The terminal, the Warp Agent CLI and MCP support are free. The Free plan has no included AI usage: you buy usage without a subscription at a 20% premium ($12 for $10 of usage) or bring your own OpenAI, Anthropic or Google key, a ChatGPT or SuperGrok subscription, or a custom endpoint.

Does Warp still use credits or AI requests?

Self-serve plans now show usage in dollars at public API rates: each prompt costs what its tokens cost on the chosen model. Credits remain on Enterprise contracts that bill in credits, and Warp's docs define a credit as a usage unit, not a token or a fixed number of prompts.

What happens when I run out of Warp usage?

Warp uses included usage first, then purchased usage. With nothing left, runs stop until the monthly reset or until you buy add-on usage or turn on auto-reload. Purchased usage is shared across the team and expires 12 months after purchase; included usage does not roll over.

Is Warp Max worth it over Build?

On list prices, monthly Max costs the same as Build plus add-ons at $200 of usage or more and more below that, so it is a convenience. Annual Max at $180 a month is the lower bill above $182 of monthly usage and saves $18 a month against annual Build.

Can I bring my own API key to Warp?

Yes, on every plan since May 21, 2026, for individuals and organizations with 10 or fewer employees; larger companies need Business or Enterprise. Your provider bills the inference. On Business and Enterprise, local runs with your own key still carry a $3 per agent hour platform charge.

What do Warp cloud agents cost?

Cloud runs draw inference at API rates, compute for the sandbox (Linux from $0.003 a minute for 2 vCPUs and 4 GB) and a platform charge of $3 per agent hour of billable activity. Warp's docs price a 10-minute run with $0.40 of inference at $0.76 in total.

How do I add Twitter (X) data to Warp, and what does it cost?

Add the TwitterAPI.io hosted MCP server (https://mcp.twitterapi.io/mcp, API key as a Bearer token) to .warp/.mcp.json. Warp bills the agent work; the X reads are billed by TwitterAPI.io at $0.15 per 1,000 tweets returned, against $5.00 at the official X API's $0.005 per post read.

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.