Trae Pricing 2026: Plans, Free Tier and Costs
Nov 10, 202616 min read
Trae has a free tier you can use without paying.
You only need a paid plan once your request volume outgrows it, so the monthly price matters less than how many requests you send, whether that's from your editor or from automations like those built in Activepieces that call it on your behalf.
Trae pricing is the set of plans, from a free tier to paid subscriptions, that charge for access to the Trae AI coding editor according to a usage limit (how many fast requests, which models, and what overage you get) rather than the headline monthly price alone.
Read the price last, because it's the weakest of the four facts that carry through the rest of the article.
If you code a few hours a week, you may never hit the cap, and then the bill is zero. The free tier has capped fast requests and limited access to premium models.
Trae pricing today: the short answer
Treat the monthly price as a starting rate, not your bill. The cheapest paid plan has a monthly price on the pricing page, but that figure only buys the first plan's allowance.
You need to pay if you run out of fast requests before the month ends, need models the free tier excludes, or can't tolerate slowdowns once the cap is hit.
If you want to check a figure, it comes from Trae's pricing page or Trae's documentation, covered below.
From here on, everything measures your own usage against those limits.
What Trae is, in one paragraph
Trae is ByteDance's AI-native code editor: a development environment built around an AI assistant that chats about your code, completes it, and can carry out multi-step edits across a project.
It's an editor, not a workflow builder, so what you buy from Trae is assistant usage inside your coding sessions; Activepieces, with 747 integrations and unlimited flows on every plan including free, is where a workflow gets built.
Because each request to a premium model draws on an allowance, request volume decides the cost.
Two vendor sources supplied every price, limit and plan name in this article: the Trae pricing page, which sets out the plans and what each includes, and the Trae documentation, which explains how requests, model access and overage behave once you're using the product.
Neither requires a sales call, which is the minimum I ask of a price. Plans change, so confirm any figure there before you commit to a team purchase.
If you are running this arithmetic for your own team, see what the same workload costs on Activepieces.
Trae plans, prices and usage limits
From $8 to $200 a month: that is Trae's paid range, according to Cursor's tier comparison, so you can't plan your Cursor budget around the headline price. That 10x spread tells you nothing until you know the usage behind each step.
Copilot spans $10 to $100 on the same page, only 10x, so Trae's top plan costs twice Copilot's.
Read the "not stated" cells as the real finding: the figures that set your bill are missing from the comparison. The table lists each price point I can confirm.
| Plan | Monthly price | Annual price | Included features | Fast requests | Slow requests | Model access | Seats | Vendor link |
|---|---|---|---|---|---|---|---|---|
| Free tier | not stated | not stated | not stated | not stated | not stated | not stated | not stated | not stated |
| Entry paid plan | $8 | not stated | not stated | not stated | not stated | not stated | not stated | not stated |
| Top plan | $200 | not stated | not stated | not stated | not stated | not stated | not stated | not stated |
Prices and plan limits checked against trae.ai on November 10, 2026.
Before you buy, every blank is a question to answer on the vendor's pricing page.
You can't budget a cap you can't count. The Free tier offers auto mode only with limited usage and 5000 autocompletions a month.
The $8 entry price is the headline, leaving most users to pay considerably more. Divide it by your monthly fast requests and you get your real cost per request, which is the only number that compares plans fairly.
The source doesn't publish that allowance, so the $8 can't yet be turned into a per-run cost.
Team or enterprise plans
Upgrading from entry means a steep financial jump: the $200 top plan is 10 times the $20 entry price. It only pays off if your volume is 25 times higher, or if it unlocks model access the cheap plan lacks.
You can't price a team purchase from this table alone, because seat counts and overage rates aren't stated. Get those in writing first, then pick the plan from your request volume.
What Trae costs for three realistic workloads
The bill for each workload is the plan's seat price times seats, plus whatever you spend past the included fast requests.
The cheapest plan is the one whose limit sits just above your monthly request volume.
The table shows that arithmetic for three users, and the takeaway is that the total tracks request volume, not the headline price, meaning your actual cost depends on your usage, not your tier.
| Workload | Monthly requests | Plan landed on | Line items per month | Cost per seat | Total monthly bill |
|---|---|---|---|---|---|
| Solo developer, light use | Well under the included fast-request limit | Entry tier | Base plan only | The base price | One seat's base price |
| Three-person team, steady use | Near, but inside, each seat's limit | Paid tier, one seat each | Three base prices | The base price | Three times the base price |
| Heavy agent user | Over the included limit | Paid tier, then overage | Base price plus overage charges | Base price plus overage | Base price plus whatever the overage adds |
Read across the rows: the first two bills are fixed and predictable, and only the third moves with usage. The rest of the section walks through each.
When a light user never touches the limit, the bill is the base price and nothing else. Overage never triggers, which means paying for a higher tier buys headroom you won't use.
When one person burns through their allowance, it doesn't borrow from the other two. Limits apply per seat, so a team's total is three base prices, not one price shared.
The risk is uneven use, so check each person's request count before you decide the tier is enough.
Once agent runs fire many requests per task, this user crosses the limit first and pays overage on every request after it. Compare two numbers: the base price plus overage at your real volume, and the next tier up.
Once overage exceeds the gap between tiers, the higher plan is the cheaper one.
Where Activepieces fits next to Trae
Nothing about Activepieces changes Trae's price or your request count: its Free plan is $0 with 1,000 credits a month and unlimited flows, so the script Trae writes can run without drawing on your Trae allowance.
Once overage exceeds the gap between tiers, the higher plan is the cheaper one.
If you pay for heavy model access daily, that spend stays where it's.
Why Trae can't run automations by itself
Trae is a code editor with an AI assistant. It drafts the script, you test it, and then it sits in a project folder doing nothing.
Trae has no scheduler, no listener for incoming events, and no place to keep a workflow alive after you close the window. Every request spent on that script was spent on authoring, and none of it buys execution.
Filling that gap is Activepieces, whose core carries an MIT licence in the LICENSE file of its public GitHub repository, and whose 747 integrations are counted from the community integrations directory of that same open source monorepo, so you can self-host it.
A finished script goes in as a step, and the platform fires it from a clock-based schedule or from a webhook, which is a URL that other software calls when something happens.
[Illustration: Trae hands a finished script to Activepieces, an MIT-licensed core with 747 integrations, which runs it on a timer or a webhook.]
How the two products bill
What to take from it: the two products bill for different things. Trae's limit is how many AI requests you make while writing.
Activepieces' cost is about how often the workflow runs, and where: 1 credit a run on the cloud plans, with Plus at $20 a month for 10,000 credits, so active users pay a predictable monthly fee instead of scaling charges.
That split is why a script you generate once can run thousands of times without touching your Trae quota.
When you self-host, part of the bill moves to your own server, a cost you can calculate from your own run volume rather than guess.
How workflow credits compare to per-task billing?
Activepieces' pricing page counts a flow run as 1 credit however many steps it contains, where Zapier bills per task and Make per module, so a ten-step workflow costs the same as a two-step one.
The Free plan includes 1,000 credits a month, and Plus is $20 a month for 10,000 credits, then $0.007 a credit over, which means overages add up fast if you exceed your tier.
Run those figures against your own expected monthly executions, then settle these, in this order:
- How your AI steps are rated: a fast model is 2 credits, a smart model 10 and a frontier model 20, unless you bring your own AI keys on Plus and up, where each AI step is 1 credit and the model cost goes to your own provider bill.
- Whether the self-hosted edition carries the same limits as the hosted one, or drops some of them.
- What happens past the included volume: a hard stop, or overage billing.
- Whether any price shown requires contacting sales. If it does, treat the tier as unpriced until someone writes a number down.
Add the result to your Trae plan. That sum is your real bill.
Worth checking against a plan that does not meter every step: one credit covers a whole run on Activepieces.
Hidden costs and limits Trae users run into
Until you know how fast one habit drains the allowance, overage is invisible.
Max Mode drains it quickly: a single session used 58 of a Pro plan's 600 Fast Requests, according to Trae's update post, so you burn through roughly 10% of your monthly quota in one session.
About ten such sessions empty the month, since that session leaves 542 Fast Requests, leaving little room for other features if you use Max Mode heavily, so you must choose between Max-Mode experimentation and concurrent feature development each month.
According to Trae, Max Mode offers a 200k context window and up to 200 tool calls per session. That's the reason a session costs so much: the agent reads and acts far more than in a normal chat turn. Count sessions, not days.
Before you assume parity, check the plan page.
The update post doesn't list model access by plan, and which models each plan unlocks decides whether your 600 requests go to the model you want, meaning you could exhaust your entire allocation on models your plan doesn't actually unlock.
If your volume doesn't hold for twelve months, annual discounts won't matter. Before committing, check these five points:
- Fast versus slow queue: the update post's silent on how the two differ.
- What happens when the allowance ends: the update post's silent on slowdown versus a hard stop.
- Model availability by plan: the update post's silent.
- Annual versus monthly billing: the update post's silent on any discount.
- Seat minimums: the update post's silent.
With five silences, the real bill can't be calculated from this page alone. Get each answer in writing from the pricing page or support before you pay.
You won't find a free-tier request cap or data-handling terms in the update post. Don't send proprietary code through any tier until you've read the privacy policy. For a team, that unread document can matter more than the monthly price.
Trae versus Cursor, Copilot and Windsurf
Trae is cheaper when your monthly volume fits inside its fast-request allowance, and the other three win once a model's cost per request, not the plan price, becomes your bottleneck.
That follows from the limit each vendor meters, and the table shows those limits side by side.
Prices change often; read the number from the vendor's own pricing page on the day you buy.
Price and limits side by side
| Product | Free tier | Limit that decides the plan | Past the limit |
|---|---|---|---|
| Trae | Yes | Fast requests | Slower queue |
| Cursor | Yes (Free) | Request and usage allowance | Usage-based charges |
| GitHub Copilot | Yes | GitHub AI Credits | Billed per extra credit |
| Windsurf | Yes | Prompt credits | Buy more credits |
Treat every free tier as a trial, not a plan, because each one exists to hit its limit quickly.
To see how much the unit matters, look at Copilot. According to GitHub's premium requests guide from 2025, GPT-4.5 cost 50 premium requests per prompt, so one prompt could use up a month's allowance.
In that guide, o1 cost 10 per prompt, so ten prompts drained a 100-request allowance. Claude 3.5 Sonnet cost 1, so the allowance counted prompts. GPT-4.1 cost 0, so it was effectively free inside the plan.
Trae wins when most of your prompts are routine edits and questions that fit its fast allowance. A small team doing that gets a predictable bill, and a slower queue past the limit costs time, not money.
Copilot is worth it if you can live on zero-multiplier models, because those prompts never touch the allowance. Cursor and Windsurf earn their premium when you depend on heavy models daily and would rather pay for metered usage than wait in a queue.
What to verify before buying Trae
Count your usage on Trae's free tier before you pay anything, and buy the plan whose limit covers it, because your bill is the usage you actually generate. Five steps, in order, get you there:
- Log your requests per day on the free tier for a week.
- Total them and compare the total against each plan's limits.
- Pick the plan from the limit, not the monthly price.
- Test overage with one small task.
- Re-check the pricing page.
Skip the first step and you're choosing a plan from a guess, because each step feeds the next.
Keep a tally every working day: requests sent, which model handled them, and whether any were refused or slowed. One week is enough because it includes your heavy days and your quiet ones.
Resist estimating from memory. Builders consistently undercount, since every retry and follow-up prompt is a request the plan counts.
Choose the plan by the limit it enforces
Set your weekly total against what each plan allows for fast requests and model access. Pick the cheapest plan whose limit sits comfortably above your busiest day, not your average one.
When a plan that looks cheap runs out midweek, you land in overage or slower responses, and that's where the sticker price stops being the bill.
Then test overage deliberately. Run one small, low-stakes task after you hit the limit and note what happens: a charge, a slowdown, or a block. Learn that on a throwaway task, not during a deadline.
Next quarter the numbers you read today may not hold, because plan limits and model access change.
Put a recurring reminder in your calendar to reopen the pricing page and rerun your tally. If your volume's shifted or the limits have, switch plans then rather than after a surprise charge.
Frequently asked questions
Free tier and plan changes
Although Trae has a free tier, it's capped by the same request and model-access limits that govern the paid plans.
Free is a starting allowance, not an unlimited seat, so count your monthly requests against it before assuming the bill stays at zero. Trae's pricing page lists the current allowance.
You handle plan changes and cancellation from your account settings, not through a sales conversation. What I can't tell you is how a mid-cycle switch is prorated or whether unused requests carry over.
Read the billing terms on the pricing page before you switch, because that detail decides whether timing saves you money.
Discounts and team seats
Check the pricing page for any current student or team offers; they change, and I won't quote one I can't verify.
For teams, the useful question is whether seats pool request limits or each person gets a separate allowance. That changes your cost far more than a percentage discount would.
Privacy and your own models
Read Trae's privacy policy and terms directly, not marketing copy, because the answer on training data lives there.
Look for whether data collection differs between free and paid use, and whether there's an opt-out. If you work with client code, get that answer in writing before you commit.
To add models through your own provider credentials, use Trae's settings, and check the docs for which providers it supports. The trade-off is that the provider then bills you per token, so you swap a fixed plan limit for a variable bill.
Run that math on your real volume before treating it as a way around the cap.
Related reading
References
Running the numbers
See what the same workload costs here.
Free forever plan, and every paid plan self-hosts at no extra cost.
See pricing Talk to sales
