Codeium pricing

About

Codeium is a Palo Alto-based AI coding company founded in 2021 as Exafunction (a GPU virtualization startup) that pivoted to AI coding tools in 2022 under CEO Varun Mohan and CTO Douglas Chen. It shipped two product lines: the Codeium extension, a free AI coding assistant that dropped into existing editors, and Windsurf, an AI-first standalone IDE launched in November 2024 around the Cascade agent.

Neither brand has its own pricing surface any more. As of the 2026-07-21 capture, both codeium.com/pricing and windsurf.com/pricing resolve to devin.ai/pricing, a page headed “Devin — Plans and Pricing” and operated by Cognition. The plan lineup, feature matrix, and FAQ on that page are Devin’s, not Codeium’s: the old extension now appears as Devin’s Tab completions row (unlimited on every tier) and the Windsurf IDE as Devin Desktop, alongside a cloud-agent product (Devin Cloud, with DeepWiki, the Devin API, and Ask Devin). The page’s own support copy refers to “the Cognition team.” See the sibling Windsurf blueprint for the ownership timeline and the Cognition blueprint for the Devin-native view.

Practically, this means the Codeium pricing story is now a Devin pricing story: a $0 free tier with a light agent quota, two individual paid tiers, a two-part team plan that separates a platform fee from per-developer seats, and a sales-quoted Enterprise tier. The credit abstraction that defined Codeium/Windsurf pricing (Flows and prompt credits) is gone from the page entirely, replaced by a usage allowance that refreshes on a daily and weekly cycle with overage purchased at underlying model API pricing. It competes with Cursor and GitHub Copilot from a materially different billing posture than the one Codeium launched with.

Pricing summary : How the Codeium/Windsurf surface prices today as Devin

The pricing page that codeium.com/pricing now serves prices a single product family in two blocks: “Individual Plans” (Free, Pro, Max) and “Team Plans” (Teams, Enterprise). Individual plans are flat monthly subscriptions with a bundled agent usage allowance; the team plan splits into a platform fee plus per-developer seats. Enterprise is the only tier without a published number.

The published stack is: Free $0/month → Pro $20/month (badged “Popular”) → Max $200/month (badged “New”) → Teams from $80/month, at $40/month per full dev seat → Enterprise “Let’s talk”. No annual-billing toggle, currency selector, or discount ribbon is present on the page.

Billing dimensions visible on the surface:

• Subscription seats — Free, Pro, and Max each cover 1 member, and Devin’s billing docs confirm Pro and Max “cannot be shared across multiple users.” Teams provides “Unlimited flex seats” plus $40/month per full user; the footnote reads “Each full user includes their own generous quota and access to Devin Desktop.” Enterprise shows Unlimited members.
• An $80/month Teams floor, not a platform fee — the pricing page renders Teams as “$80/month for team plan + $40/mo per full dev seat,” which reads as additive. The self-serve billing docs are explicit that it is a minimum: “Every Teams subscription costs at least $80/month. You can hit this minimum in any combination of full seats ($40 each) and on-demand credits.” Their worked table gives one full seat → still $80, two full seats → exactly $80, and any count at or above two full seats → simply N × $40 with nothing added on top. Below two full seats, the shortfall is charged as prepaid on-demand credits the whole team can draw from — so a ten-developer Teams account bills as ten $40 seats, not ten seats plus a separate platform fee.
• Agent usage quota — every paid plan carries “a usage allowance that refreshes automatically on a daily and weekly basis.” The docs add the shape: Pro and Teams full seats get a daily and weekly allowance (the daily is deliberately more than 1/7 of the weekly), while Max gets a weekly allowance only, with no daily cap. The FAQ is explicit that “Cost per message varies based on the model used, the task size and complexity, and the reasoning required,” so the quota is denominated in model consumption rather than a fixed action count. Free is described only as “Light quota to code with agents.”
• Overage as prepaid on-demand credits — “If you do go beyond your included usage on a paid plan, you can purchase extra usage which is consumed at API pricing.” Pro lists “Purchase extra usage at API pricing” as a plan bullet. The docs name that mechanism on-demand credits: prepaid, topped up from Settings > Plans with optional auto-reload, shared across all members on Teams, and they “roll over month-to-month” and “never expire.” There is still no published per-credit or per-message rate.
• Model availability as a gate — Free is “Limited model availability”: premium models are off and “Free SWE 1.7” is marked Slow rather than unavailable. Pro and above unlock premium models and full-speed free SWE 1.7. Fast context and unlimited Tab are checked on every tier including Free.
• Concurrency — the comparison table meters concurrent sessions: not available on Free, “Up to 10” on Pro and Max, Unlimited on Team and Enterprise.
• Unmetered surfaces — Tab completions and inline edits are Unlimited on every tier including Free, the direct descendant of the free Codeium extension.

What makes this different: the Teams tier separates the practitioner from the participant — only developers who need their own quota and Devin Desktop cost $40/month, while unlimited flex seats are free and simply draw on the team’s shared credit pool. The $80/month figure is a floor, not a workspace fee: it is fully absorbed once two developers hold full seats. That lets non-coding stakeholders sit in the workspace at no marginal seat cost while the account still carries a small guaranteed monthly commitment.

Pricing by product

Devin, formerly Codeium / Windsurf (Individual plans)

Devin (Team plans)

Sales motions across products: PLG / self-serve for Free, Pro, Max and Teams (all buyable via “Select plan”); sales-led for Enterprise (“Contact us” / “Contact sales”).

Hidden costs : What Windsurf users actually pay beyond the base plan

Archetype A: Solo developer on Windsurf Pro

An individual developer using Windsurf Pro as their primary IDE for daily coding work, including Cascade agent tasks:

The 600 credit monthly allocation covers light-to-moderate usage comfortably — roughly 50–100 typical Cascade interactions per month. Heavy users running multi-step refactor agents (10+ file changes per session) can exhaust credits faster, leading to overage charges or productivity pauses at month-end.

Archetype B: 20-person engineering team on Windsurf Teams + Codeium Enterprise extension

A mid-size team combining the Windsurf IDE for senior/power users and the Codeium extension for all engineers:

The hidden complexity here is the overlap cost: organizations deploying both Windsurf (as the agentic IDE) and the Codeium extension (for engineers in their preferred existing editors) pay two separate seat licenses. Codeium’s sales team typically negotiates bundle pricing for this scenario, but it is not transparent from the public pricing page.

Want to estimate your own Windsurf bill? Use the Codeium pricing calculator to model your monthly cost based on team size and usage patterns.

Pricing evolution : from free Codeium extension to Flow credits to the Devin plan lineup

Cadence

Tracked range: 2022 Q2–2026 Q3. Quarters not listed above were verified stable (0 price changes, 0 SKU additions).

Notable changes

• 2022-06-01 — Codeium extension launched free. Positioned as direct counter to GitHub Copilot Individual ($10/month), Codeium’s free-forever individual tier attracted hundreds of thousands of developers within the first year.
• 2023-05-01 — Codeium Enterprise launched. First monetized product; pricing is sales-led and not publicly disclosed. Marked Codeium’s entry into the enterprise market against GitHub Copilot Business ($19/user/month) and Tabnine Enterprise.
• 2024-08-01 — $150M Series C at $1.25B valuation. General Catalyst-led round validated the free-extension model as a viable enterprise distribution strategy. Funds directed toward Windsurf development.
• 2024-11-13 — Windsurf IDE and Pro plan ($15/month) launched. The Cascade agent demo drove 100,000 sign-ups in 72 hours. Windsurf entered the agentic IDE market alongside Cursor, immediately differentiated by the Flow credit abstraction vs Cursor’s API-cost pool.
• 2025-01-01 — Windsurf Teams ($35/user/month) launched. Added team-level credit management and admin console. Teams minimum 3 seats.
• 2025-05-06 — OpenAI announces acquisition of Windsurf for ~$3 billion. Existing Windsurf pricing guaranteed stable through end of 2025. The deal marks a significant escalation in the AI IDE market consolidation after Microsoft’s GitHub Copilot dominance.
• 2026-01-01 — Windsurf Pro credit allocation expanded by ~20% with no price change. Post-acquisition product integration with OpenAI’s model stack complete.
• 2026-07-21 — Both Codeium-branded pricing surfaces retired. codeium.com/pricing and windsurf.com/pricing resolve to devin.ai/pricing, a Cognition-operated page with no Codeium SKU left to buy. The individual paid entry point rises from $15/month to $20/month, a $200/month Max tier appears, and Teams changes shape entirely: from $35/user/month to $40 per full dev seat charged against an $80/month account minimum, with unlimited free flex seats alongside. Flow and prompt credits disappear from the page in favour of a usage allowance that refreshes daily and weekly, with work past it funded by prepaid on-demand credits consumed at model API pricing.

The Devin consolidation in detail

The 2026-07-21 change is a brand retirement carrying a repricing inside it, and the two are easy to conflate. Three things moved at once:

• The surface. There is no Codeium plan lineup any more — only Devin’s. The products survive as feature rows rather than SKUs: the free Codeium extension is now the Tab row (Unlimited on every tier, including Free), and the Windsurf IDE is Devin Desktop, which only full users on a billed seat receive. A buyer arriving from a 2025 Codeium quote has no like-for-like line item to renew.
• The price. Individual paid entry moved $15 → $20, erasing the 25% undercut that was Windsurf’s sharpest positioning against Cursor Pro, and adding Max at $200 as a pure usage-headroom step above it. Teams moved from $35/user/month to $40 per full dev seat against an $80/month account minimum, with unlimited free flex seats — modestly more expensive per active developer, and dramatically cheaper for the reviewers, leads, and PMs who used to need a seat to see anything.
• The meter. Flow credits were the abstraction the old pricing was built on: a countable unit a buyer could budget (“600 credits/month”). The included allowance that replaced them has no published denomination, refreshes on daily and weekly cycles (weekly only on Max), and the page states cost per message “varies based on the model used, the task size and complexity, and the reasoning required.” Credits survive only past the allowance, as prepaid on-demand credits bought to fund overage at API pricing — so the unit a buyer can count is now the one they pay extra for, not the one they are entitled to.

The net effect for an existing Codeium or Windsurf customer is that none of the three anchors they priced against — the brand, the number, or the unit — survived the transition intact. Anyone still modelling this spend on Flow credits is modelling a mechanic that no longer exists.

What’s unique : the flex-seat split, the undenominated quota, and a brand priced away

1. The participant is free; only the practitioner is billed. Teams charges $40/month per full dev seat and nothing at all for “Unlimited flex seats” — flex members can sit in the workspace, see the work, and draw on the team’s shared credit pool, but they get no personal quota and no Devin Desktop. Most AI coding tools charge one rate for everyone with an account, which taxes the tech lead, the reviewer, and the PM who only ever read agent output. Here a 30-person product org with 8 hands-on developers buys 8 seats, not 30, and each upgrade is a reversible admin action rather than a contract change. The $80/month figure attached to Teams is a floor rather than a workspace fee — full seats count toward it, so it disappears entirely once two developers are billed, and below that the remainder is issued as prepaid credits rather than kept. It is a hybrid shape where the guaranteed minimum is small and the real variable is how many people need their own capacity.

2. The entitlement has no denomination — but the overage does. Paid plans carry “a usage allowance that refreshes automatically on a daily and weekly basis,” with cost per message varying “based on the model used, the task size and complexity, and the reasoning required.” No credit count, no message count, no rate. Yet the moment you exceed it you are buying on-demand credits, a perfectly countable prepaid unit that rolls over month to month and never expires — and Enterprise contracts are billed in ACUs at an order-form rate. So the vendor has denominated units; it simply does not use them to describe what a subscription includes. Compare the same product a year earlier, which sold “600 Flow credits per month.” The usage metric that buyers can count is now the one they pay extra for.

3. Two refresh clocks, and Max removes one of them. Pro and Teams full seats get both a daily and a weekly allowance, where the daily is deliberately larger than a seventh of the weekly; Max drops the daily cap and runs on a weekly allowance only. That is packaging as rate-limiting: short cycles stop one heavy afternoon from stranding a developer for three weeks, and paying 10× for Max buys not just more capacity but the removal of the daily governor — the freedom to spend a whole week’s allowance in one sitting. Neither allowance rolls over. It is a materially different billing-cycle design from the monthly credit pool the category grew up on, and it changes what “running out” means from a month-end cliff to a next-morning wait.

4. Overage is priced at cost, and the credits behind it never expire. “Purchase extra usage which is consumed at API pricing” is an unusual overage promise: the escape hatch is sold at the underlying model rate rather than a marked-up per-credit price, and the prepaid credits funding it roll over month to month, never expire, and are shared across everyone on a Teams account. That removes both halves of the classic AI bill-shock pattern — no punitive overage multiple, and no use-it-or-lose-it forfeiture on money already spent. The catch is that a rate defined as “API pricing” moves whenever the model vendors reprice, so the buyer’s marginal cost is indexed to a third party’s price list rather than to their contract.

5. The free tier is unmetered where it is cheap and gated where it is not. Tab completions and inline edits are Unlimited on every tier including Free — the direct descendant of the free Codeium extension that built the user base — while agent runs, premium models, and the entire Devin Cloud block are gated. That is a precise reading of where inference cost actually sits: completion is cheap enough to give away forever, agentic reasoning is not. The free-tier restructuring visible across the category is exactly this move, and Codeium’s page is one of the cleanest examples of it.

6. A brand with 700K+ users was priced out of existence. As of 2026-07-21 there is no Codeium SKU. The extension is a feature row (“Tab”), the IDE is a deliverable attached to a paid seat (“Devin Desktop”), and the pricing URLs redirect. Consolidations usually retire a brand’s marketing site and keep its plans as a migration path; this one retired the plans first. For anyone tracking acquisition outcomes in developer tools, the pricing page is the earliest reliable signal of whether an acquired product is being kept as a product or absorbed as a capability.

Strengths & weaknesses

Billing UX : named billing controls on the page Codeium now redirects to

• “Select plan” self-serve checkout — Pro, Max and Teams each carry a “Select plan” button; Free carries “Download”; Enterprise carries “Contact us” (with a “Contact sales” link in the top nav). Four of five tiers are buyable without a sales conversation.
• Daily and weekly quota refresh — the FAQ states each paid plan’s usage allowance “refreshes automatically on a daily and weekly basis,” rather than a single monthly bucket. Devin’s docs qualify this: Pro and Teams full seats get both a daily and a weekly allowance, Max gets a weekly allowance with no daily cap, and the allowance itself does not roll over (the daily bucket is set at more than 1/7 of the weekly so weekend work does not cost you week-level capacity). No in-page meter of remaining quota is shown on the pricing page.
• “Purchase extra usage at API pricing” — the published overage control. Exceeding included usage on a paid plan does not hard-block; the page directs users to buy extra usage consumed at API pricing. The rate itself is not stated on the pricing page.
• On-demand credits with auto-reload — the docs-side name for that overage balance, and the one thing on the surface that does roll over: credits “roll over month-to-month” and “never expire,” are topped up from Settings > Plans, and can be refilled automatically via auto-reload. Admins set auto-reload thresholds and default per-session spending limits from Settings > Usage. On Teams the pool is shared across all members with no per-member balance. Legacy ACU balances carry across at par — “On-demand credits are the same dollar value as the ACUs you’re used to.”
• The $80/month Teams minimum as a billing control — with fewer than two full seats, the unmet portion of the minimum is not lost: it is charged as prepaid on-demand credits the whole team can spend. Seat type is set at invite time and convertible later from Settings > Members, so admins move people between the $40 metered seat and the free flex seat as usage patterns change.
• Usage-stretching guidance in-page — a dedicated FAQ (“How can I make my usage limits last longer?”) tells users to control prompt size and “switch to smaller models for routine tasks,” naming Haiku, GPT 5.2 Mini and open-source models like Kimi K2.5. Model choice is presented as a first-class cost lever.
• Admin dashboard with analytics — a named Teams entitlement, paired with centralized billing for the team plan.
• Flex-seat vs full-user split — the comparison table exposes the seat control directly: “Unlimited flex seats” on Team with ”+$40/month per full user,” where only full users get their own quota and Devin Desktop access. Flex seats carry no fixed monthly charge at all and draw entirely on the shared credit pool, so admins choose who is upgraded to a billed seat.
• Concurrent sessions limit — an explicit throttle row in the comparison table: unavailable on Free, “Up to 10” on Pro and Max, Unlimited on Team and Enterprise.
• Enterprise administration — SAML/OIDC SSO, centralized enterprise admin controls, teamspace isolation, VPC deployment, custom terms, and “centralized management of multiple Devin organizations” for multi-org billing structures.
• Stripe-hosted customer portal — Devin’s own docs route paid users to “a secure Stripe pop-up” and “your customer portal on Stripe” for subscription management (docs accessed 2026-06-18).

Strategic wins : Why Codeium and Windsurf’s pricing decisions worked

1. Free extension as an enterprise Trojan horse

Codeium’s decision to make the coding extension free forever — with no completions cap — was strategically brilliant. In a market where GitHub Copilot charges $10/month per developer, offering zero-cost AI completion drove massive organic adoption inside engineering organizations. When those same organizations evaluated enterprise AI coding purchases, their developers were already advocates for Codeium. This bottom-up enterprise motion is the same model that drove Slack and Atlassian to dominance: make the individual tool so good that the enterprise purchase becomes inevitable. The $150M Series C at $1.25B valuation validated the bet — the free extension was acquiring enterprise customers at zero direct CAC. The bet is still being honoured after the 2026-07-21 consolidation: Tab completions and inline edits stayed Unlimited on every tier, so the funnel survived even though the brand did not.

2. The $15 undercut bought category share while the window was open

When Cursor established $20/month as the agentic IDE price point, it created an implicit industry floor. Windsurf’s $15/month Pro price was a deliberate 25% undercut that forced Cursor users to justify the price difference, and combined with the Cascade agent it drove rapid share capture through 2025. The instructive part is the exit: on 2026-07-21 the individual paid tier moved to $20/month, giving the undercut back once the user base was established and the product sat inside a larger portfolio. Entry discounts in developer tools are best understood as a purchased option on adoption, not a permanent position — price sensitivity is high at acquisition and materially lower at renewal.

3. Flow credits bought a trust advantage during the category’s worst billing year

Cursor’s June 2025 transition to API-cost pool pricing triggered widespread user backlash — unexpected bills of $10–$20/day and a public CEO apology. Windsurf’s Flow credit model, launched before this controversy, insulated it from similar anxiety: “I have X credits this month” was a simpler mental model than a dollar pool draining at model-specific rates, even where the underlying economics were similar. That advantage was real and it was temporary. The 2026-07-21 page retires credits for an allowance with no published denomination, which trades the countable unit back for vendor flexibility — a reminder that billing predictability is a position a vendor holds rather than a property a product has.

4. The $3B acquisition price validated the free-to-enterprise flywheel

The OpenAI acquisition at ~$3B — compared to Codeium’s last valuation of $1.25B — represents a 2.4× premium in roughly 9 months. This premium reflects not just Windsurf’s technical capabilities but the strategic value of its developer distribution: 700,000+ individual users, enterprise relationships, and the only IDE with a differentiated agentic engine outside Microsoft’s GitHub Copilot ecosystem. Acquiring that distribution was cheaper than building an equivalent developer channel from scratch, and the pricing strategy — free extension driving enterprise relationships — directly created the acquisition value. The 2026-07-21 retirement of both pricing surfaces is the endgame of that trade: the acquirer bought a user base and a capability, and once both were absorbed there was no reason to keep operating a second price list.

5. Teams bills the practitioner and lets everyone else watch for free

The Teams construction introduced on the 2026-07-21 page — $40/month per full dev seat against a small account floor, with unlimited free flex seats — fits how agentic coding actually gets adopted better than a flat per-seat license does. Adoption starts with a handful of engineers, while managers, reviewers, and PMs mainly need to see what the agents did. Charging the observers nothing removes the usual reason admins under-provision access, and it turns each upgrade into a reversible per-person decision rather than a seat-count negotiation. It is the same insight behind moving away from per-user licenses, applied to the seat itself rather than to the meter — and it quietly reframes the buying question from “how many people use this?” to “how many people need their own capacity?”

Areas to improve : an unquantified quota, an unpriced Enterprise tier, and an unmapped migration

1. The usage allowance needs a published denomination

Since 2026-07-21 the paid plans are sold on “a usage allowance that refreshes automatically on a daily and weekly basis” with no number attached to it anywhere on the page — no credit count, no message count, no rate. That is strictly less information than the 600-Flow-credit figure the same product published a year earlier, and it makes the $20-versus-$200 decision unanswerable in advance: Max is described only as “significantly higher quotas,” so a buyer cannot tell whether it is 3× Pro or 30× Pro. The gap is self-inflicted, because the denominated units already exist — on-demand credits for overage, ACUs on Enterprise order forms — they are just not used to describe what a subscription includes. A well-chosen value metric has to be countable by the buyer, not only by the vendor’s billing system. Two concrete fixes: express each plan’s allowance in the same on-demand-credit unit buyers are already charged in when they exceed it, and expose a live remaining-allowance meter in-product so the entitlement is at least observable after purchase.

2. No public enterprise pricing creates friction for bottom-up procurement

Teams is now fully public at $40 per full dev seat against an $80/month floor, which narrows the transparency gap — but Enterprise remains “Let’s talk” with no published band, and it is billed on an entirely different meter (ACUs at an order-form rate) that self-serve buyers never see, against GitHub Copilot Enterprise at a transparent per-seat rate. For engineering leaders running bottom-up evaluations, the absence of a public number is a procurement barrier: the tool cannot be entered into an internal cost comparison without a sales conversation, exactly at the moment a champion is trying to build the case. Pricing transparency is a competitive advantage in developer tools, where champions rather than buyers drive selection. Publishing a floor (“from $X/seat/month, minimum N seats”) would preserve negotiating room while letting the tier survive a spreadsheet.

3. The consolidation shipped without a customer-facing migration map

Cognition clearly knows how to do this: the billing docs describe migrating legacy ACU-era Core users onto the Free plan with their remaining credits preserved. Codeium and Windsurf customers got no equivalent bridge on the 2026-07-21 page. Windsurf Pro at $15 has no successor labelled as such — the nearest equivalent is $20 on a different meter; Windsurf Teams at $35/user maps to a seat-plus-floor structure whose per-developer cost depends on how many people are upgraded; and Flow credits have no stated conversion into either the new allowance or on-demand credits. Renewal conversations are where consolidations lose accounts, and the fix is cheap: publish the same kind of mapping already written for Core users — legacy SKU → current plan, credit balance → on-demand credits, with a worked example converting a 20-seat Windsurf Teams contract into full dev seats. Without it every legacy account has to be re-sold rather than migrated, which is how billing changes turn into churn.

Key takeaways

1. Free forever individual tiers create enterprise distribution advantages that no amount of sales spend can replicate. Codeium’s free extension drove 700K+ developer users who became internal advocates — turning every developer’s laptop into a sales channel. For developer tool companies, PLG-first combined with a genuinely useful free tier is more efficient than enterprise sales at scale.

2. A countable unit is a promise, and dropping it is a repricing even when no price moves. Windsurf sold “600 Flow credits per month”; the 2026-07-21 page sells “a usage allowance that refreshes daily and weekly” with no number. Nothing on the invoice changed for a new buyer, but the buyer’s ability to forecast did — so treat the denomination of your meter as a contractual feature, and expect to lose credibility if you retire it without replacing it with something equally countable.

3. Aggressive entry pricing is an option you buy, not a position you hold. Windsurf’s $15/month undercut of Cursor’s $20 drove rapid switching while switching cost was low, and the price moved to $20 on 2026-07-21 once the user base and the parent portfolio were established. If you are planning an undercut, plan the exit at the same time: name the condition that ends it and the migration story you will tell, because entry pricing that is never unwound just becomes a permanent margin cut.

4. The free-to-enterprise flywheel creates acquisition premium. Codeium’s $3B acquisition price at a 2.4× premium to last valuation reflects the strategic value of developer distribution — not just technical capability. Companies that build free-tier user bases that become enterprise procurement champions are acquired at premiums, not discounts, because that distribution is hard to replicate.

5. The pricing page is the first place an acquisition’s real intent becomes visible. Roadmap statements after a deal are cheap; the plan lineup is not. On 2026-07-21 both Codeium URLs began resolving to a Devin page with no Codeium SKU, which settled a question no press release had — the products were absorbed as capabilities, not kept as products. If you are evaluating an acquired vendor, watch whether its plans survive the first pricing-page refresh, and if you are the acquirer, understand that retiring a price list reads to customers as retiring the product.

UBP implications

1. Give away the cheap surface forever; meter the expensive one. Codeium’s free-to-paid funnel outlived its own brand because the split was drawn along cost lines rather than feature lines: completion and inline edits stayed Unlimited on every tier through the 2026-07-21 consolidation, while agent runs, premium models, and cloud agents became the metered goods. For companies building usage-based pricing for developer tools, that is the durable version of freemium — the free tier is not a crippled product, it is the part of the product whose marginal cost approaches zero, and it keeps working as a distribution engine even through an ownership change.

2. The credits-versus-cost-pool debate has a third answer, and it is winning on the vendor side: denominate the overage, not the entitlement. Windsurf’s Flow credits and Cursor’s dollar-denominated pools both told a buyer how much AI they had bought. The 2026-07-21 lineup does not: the included allowance is unquantified, while the things past it — prepaid on-demand credits, and ACUs on Enterprise order forms — are precisely counted. That asymmetry is rational under volatile inference costs, because an unnamed entitlement never has to be repriced when model rates move, and it is likely to spread. But it pushes forecasting entirely onto the buyer, which is why finance teams increasingly need usage aggregation on their own side of the wire rather than trusting a vendor-defined unit. Expect procurement to respond by asking for a contractual capacity floor expressed in whatever unit the vendor uses to bill overage.

3. Consolidation compresses price lists faster than it compresses products. When an acquirer absorbs a monetised product, the pricing surface is the cheapest thing to retire and the first thing to go: the Codeium extension and Windsurf IDE both still ship, but as feature rows on someone else’s plan grid rather than as SKUs. For UBP practitioners this reframes acquisition risk as meter risk — the unit you contracted on can vanish even when the software does not, and there may be no conversion published between the old unit and the new one. Model it explicitly: for any AI vendor with acquisition exposure, ask what your usage entitlement converts into if their price list is folded into a parent’s, the same way you would model a shift away from per-user licensing.

Sources

• Devin plans and pricing — the page both Codeium URLs now resolve to (accessed 2026-07-21)
• Devin self-serve billing docs — plan table, $40 full seats, the $80/month Teams minimum, on-demand credits (accessed 2026-07-21)
• Devin billing overview — self-serve plans vs Enterprise ACU billing (accessed 2026-07-21)
• Windsurf official pricing page — redirects to devin.ai/pricing (accessed 2026-07-21)
• Codeium official pricing page — redirects to devin.ai/pricing (accessed 2026-07-21)
• Windsurf IDE launch announcement — Codeium blog (accessed 2026-05-29)
• Codeium $150M Series C announcement (accessed 2026-05-29)
• Windsurf acquisition announcement — Windsurf blog (accessed 2026-05-29)
• Windsurf Cascade agent deep-dive — Windsurf blog (accessed 2026-05-29)
• Cursor pricing comparison reference — Cursor pricing page (accessed 2026-05-29)

Bottom line

Codeium built the most effective PLG-to-enterprise distribution machine in the AI coding category — a free extension with no completion cap that turned developers into advocates, and a $15/month agentic IDE that undercut the incumbent — and then, on 2026-07-21, stopped being a thing you can buy. Both pricing URLs now resolve to a Cognition-operated Devin page where the extension is a feature row, the IDE is a paid-seat deliverable, individual paid entry is $20/month, and Flow credits have been replaced by an allowance with no published unit and overage sold at model API pricing. The Teams construction that came with the change is genuinely good pricing — $40 per full dev seat against a small floor, with reviewers and PMs riding along free — but it arrives attached to the least forecastable entitlement this product has ever shipped. Codeium is now a case study with two halves: how free-tier distribution creates enterprise value, and how quickly the price list you bought on can disappear once someone else owns it.

Browse the full pricing blueprint to compare this lineup against Cursor, GitHub Copilot, and other AI coding tools.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Codeium and Windsurf pricing surfaces retired into Devin

Jul 2026

codeium.com/pricing and windsurf.com/pricing both resolve to devin.ai/pricing. The page is branded 'Devin — Plans and Pricing' and shows Free $0, Pro $20/mo, Max $200/mo, Teams from $80/mo, and Enterprise 'Let's talk'. Devin's billing docs clarify the Teams shape: full seats are $40/mo each against an $80/mo account minimum (two full seats clear it), and flex seats are free. Flow/prompt credits are gone, replaced by a usage allowance that refreshes daily and weekly with overage funded by on-demand credits consumed at API pricing. The Codeium extension survives as Devin's Tab completions (unlimited on every tier) and the Windsurf IDE as Devin Desktop.

Windsurf Pro Repriced at $15/month; Credit Pool Expanded

Jan 2026

Windsurf Pro holds at $15/month (not increased post-acquisition) but Flow credit allocation per month is expanded by ~20% to 600 credits/month. Enterprise pricing moves fully under OpenAI's enterprise sales motion. The free Codeium extension continues independently under the original Codeium entity.

Post-Acquisition: Windsurf Integrated Into OpenAI Ecosystem

Sep 2025

Following the acquisition close, Windsurf users gain optional access to OpenAI's o3 and GPT-4o models natively inside the IDE. OpenAI ChatGPT Pro subscribers receive Windsurf Pro access bundled at no additional cost — effectively making Windsurf a benefit layer on top of the ChatGPT subscription stack. Pricing for standalone Windsurf plans unchanged through end of 2025.

OpenAI Acquires Windsurf for ~$3 Billion

May 2025

OpenAI announces the acquisition of Windsurf (the IDE product and brand) for approximately $3 billion — the largest known AI tooling acquisition to date. The deal covers the Windsurf IDE, Cascade agent technology, and associated IP. The Codeium extension and enterprise business are expected to continue under separate ownership. Existing Windsurf subscribers notified that pricing and plans will remain stable through end of 2025.

Windsurf Teams Plan Launched at $35/user/month

Jan 2025

Windsurf adds a Teams tier at $35/user/month with team-level credit management, centralized billing, admin console, and priority support. Minimum 3-seat purchase. The Teams tier adds workspace-level sharing, team snippet libraries, and role-based access controls.

Windsurf IDE Launched — AI-First IDE with Cascade Agent

Nov 2024

Codeium launches Windsurf, an AI-first IDE built on top of VS Code's open-source core (Code OSS). The headline feature is Cascade, a multi-step agentic engine that can plan and execute complex coding tasks spanning multiple files, terminal sessions, and browser feedback. Windsurf Free tier includes 1 free Flow/month. Windsurf Pro launched at $15/month with 500 Flow credits/month. The launch demo video goes viral and drives 100,000 sign-ups within 72 hours.

$150M Series C at $1.25B Valuation

Aug 2024

Codeium raises $150M in a Series C funding round led by General Catalyst, valuing the company at $1.25 billion. The company reports 700,000+ individual users and growing enterprise customer traction. Funds earmarked for the upcoming Windsurf IDE and expanded model infrastructure.

Teams Plan Launched at ~$12/user/month

Nov 2023

Codeium introduces a self-serve Teams tier for smaller organizations, providing team-level administration, usage dashboards, and priority support without requiring enterprise sales engagement. Initial price approximately $12/user/month.

Codeium Enterprise Launched; Series A Funding

May 2023

Codeium launches its first paid product: Codeium Enterprise, a seat-based offering for organizations with SSO, on-premises deployment, and usage analytics. Pricing is sales-led and not publicly disclosed. The company raises a Series A to accelerate enterprise sales.

Codeium Launched as Free AI Coding Assistant

Jun 2022

Codeium launches publicly as a free AI-powered code completion and chat tool supporting 70+ languages and 40+ editors. The free-forever individual tier is positioned as a direct challenge to GitHub Copilot's $10/month minimum. No paid plans at launch.

Exafunction Founded (GPU Virtualization)

Jan 2021

Varun Mohan and Douglas Chen found Exafunction, a GPU virtualization infrastructure startup. The company pivots to AI coding assistance in 2022 after recognizing the developer tooling opportunity.