LangChain pricing

About

LangChain is the company behind the most-adopted open-source LLM application framework (launched October 2022 by Harrison Chase) and LangGraph, its agent-orchestration library (January 2024). Both frameworks are free. The business sits one layer up: the LangSmith platform — observability, evaluation, agent deployment, the no-code Fleet builder, the autonomous Engine debugger, and Sandboxes for agent-generated code — all sold from a single pricing page.

The funding arc tracks the monetization arc. A $10M Benchmark seed (April 2023) funded pure OSS distribution; the $25M Sequoia Series A (February 2024, ~$200M valuation) landed the same month LangSmith — the first paid SKU — hit general availability; and the $125M IVP-led Series B (October 2025, $1.25B valuation, with Databricks, Datadog, Cisco, ServiceNow, and Workday participating) coincided with consolidating every commercial product under the LangSmith brand.

This entry covers LangChain’s company-level monetization: the OSS strategy, deployment pricing, and the 2026 multi-SKU expansion. For a deep dive on the seats-plus-traces observability pricing specifically, see the LangSmith blueprint.

Pricing summary : How LangChain’s pricing model works

LangChain runs a textbook open-core funnel with a usage-metered top. The frameworks that made the company famous cost nothing; the hosted platform charges a per-seat subscription — Developer ($0, 1 seat), Plus ($39/seat/mo, unlimited seats), Enterprise (custom, annual invoice) — and then meters each platform service independently:

• Observability & Evaluation (traces) — 5k (Developer) or 10k (Plus) base traces/mo included, then $2.50 per 1k base (14-day retention) and $5.00 per 1k extended (400-day). Covered in depth on the LangSmith page.
• Deployment — 1 free dev-sized deployment on Plus (unlimited runs); additional deployments bill $0.005 per deployment run (one end-to-end agent invocation) plus uptime at $0.0036/min per production deployment and $0.0007/min per development deployment.
• Fleet (no-code agents) — 50 runs/mo on Developer, 500 on Plus, then $0.05 per Fleet run; every Fleet run is also traced and counts against trace billing. LLM usage is billed separately by your model provider.
• Engine (autonomous agent-fixing) — metered in LangChain Compute Units at $1.50/LCU, model usage included; roughly 30–40 LCUs on first run, 10–15 LCUs every 6 hours thereafter.
• Sandboxes (isolated compute for agent-generated code) — per-second billing at $0.0576/vCPU-hr, $0.0185/GiB-hr memory, and $0.000123/GiB-hr storage.

What makes this different: most AI-infra companies pick one value metric. LangChain stacked seven meters (seats, traces, deployment runs, uptime minutes, Fleet runs, LCUs, sandbox compute) under one stable $39 seat anchor — each new product since 2024 arrived with its own unit, and the units get more abstract as the products get more autonomous.

Pricing by product

Sales motions across products: self-serve / PLG for Developer and Plus (monthly billing, seats pro-rated, usage in arrears), sales-led for Enterprise (annual upfront invoice, committed LangChain credits, infosec review, custom terms). A separate Startup Plan offers discounted rates and free trace allotments for VC-backed early-stage teams. The OSS frameworks remain a zero-price acquisition channel feeding all of it. For a primer on picking meters like these, see choosing the right usage metric.

Hidden costs : What LangChain users actually pay

The $39 seat is the smallest number on the page. A five-person team on Plus running one production agent at moderate volume:

Four cost mechanics that don’t show up in the headline price:

1. The uptime parking meter. A production deployment bills $0.0036/min from the moment it’s live — about $155/month at zero traffic. Dev-sized deployments are 5x cheaper ($0.0007/min) but don’t scale horizontally, so customer-facing agents are pushed to the production rate.
2. Human-in-the-loop doubles runs. An interrupt for human approval creates a separate billable run on resume — on both Deployment and Fleet meters. Approval-heavy workflows pay twice per task.
3. Fleet runs cascade into traces. Every Fleet run ($0.05) is traced by default and counts toward your trace allotment — and the LLM tokens behind it are billed separately by your model provider.
4. Engine’s default schedule compounds. At 10–15 LCUs every 6 hours, leaving Engine running costs roughly $1,800–$2,700/month at $1.50/LCU — by LangChain’s own published usage ranges, potentially the largest line on the bill.

Want to estimate your own LangChain bill? Use the LangChain pricing calculator to model seats, runs, and uptime.

Pricing evolution : LangChain pricing history and changes

Cadence

Tracked range: 2024 GA → present, via Wayback Machine snapshots (2024-07, 2025-07, 2025-11, 2026-01) and a live 2026-06-10 capture. The $39 seat has never moved; all evolution happens on the usage axes.

Notable changes

• 2024-02 — LangSmith GA establishes the $0 / $39-seat / custom structure that still anchors the page today.
• 2024-06 — LangGraph Cloud beta announced with LangGraph v0.1; deployment monetization begins, off-page.
• 2025-05-14 — LangGraph Platform GA puts deployment pricing on the public page: $0.001 per node executed plus standby ($0.0036/min production, $0.0007/min dev); free self-hosted Lite tier with 100k nodes/mo.
• 2025-10 — Series B; LangGraph Platform → LangSmith Deployment, LangGraph Studio → LangSmith Studio. Every paid SKU now carries the LangSmith brand.
• 2025-11 → 2026-01 — The quiet repricing: per-node-executed billing replaced by a flat $0.005 per deployment run. Nodes and subgraphs within one invocation are no longer charged separately; an interrupt resume counts as a new run.
• 2026-03 — Agent Builder rebrands to LangSmith Fleet ($0.05/run beyond plan allotments); Sandboxes enter private preview.
• 2026-05 — Interrupt 2026: Engine launches at $1.50/LCU; Sandboxes reach GA with per-second compute billing.

What’s unique : LangChain’s distinctive pricing mechanics

1. The brand inversion. The famous name is the free thing. LangChain and LangGraph (the frameworks) cost nothing and cap nothing; 100% of monetization flows through the LangSmith brand. The company effectively renamed its paid surface away from its own household name — the opposite of most open-core plays, where the company name goes on the invoice.

2. Repricing from nodes to runs. The 2025→2026 switch from $0.001/node-executed to $0.005/deployment-run traded precision for predictability. Under per-node billing, buyers couldn’t forecast costs without knowing their graph topology; per-run billing matches the unit customers actually count (invocations). It also re-balanced who pays: complex 20-node agents got 4x cheaper, trivial 3-node graphs got 67% pricier — break-even at exactly 5 nodes.

3. A new meter per product, increasingly abstract. Traces (2024) are countable events. Runs (2026) are countable invocations. LCUs (2026) are a synthetic unit “representing work done by Engine” — compute, infra, and model usage blended, with usage estimated in ranges rather than rates. As the products climb the autonomy ladder, the units drift from observable to vendor-defined — a pattern worth watching across the agent-infra category.

4. Standby pricing for stateful agents. Charging uptime minutes ($0.0036/min production) alongside per-run fees prices the persistence of long-running agents, not just their activity — closer to database pricing than to API pricing, and a structural answer to agents that sit idle between invocations.

Strengths & weaknesses

Billing UX : LangChain billing controls and transparency

• Billing mechanics — Seats bill monthly on the 1st, pro-rated when added mid-month (no credit for removals); usage bills monthly in arrears. Enterprise is invoiced annually upfront against committed LangChain credits. Developer→Plus upgrades are self-serve from the billing page.
• Usage visibility — LCU consumption is visible in the billing console (Settings > Billing); the pricing page publishes full per-metric rate cards including tooltips for trace and run definitions. Engine can be disabled by an org admin to stop scheduled LCU burn; Fleet can be disabled via support (cloud) or Helm values (self-hosted).
• Spend control gaps — Engine usage is published as estimated ranges (10–15 LCUs per recurring run), not fixed rates, and uptime meters run continuously — both reward teams that actively manage deployments and schedules rather than set-and-forget.
• Payment options — Card-based self-serve for Developer/Plus; annual invoice, custom terms, and infosec review on Enterprise. A Startup Plan (application-based) offers discounted rates and free trace allotments.

Strategic wins : Why LangChain’s pricing decisions worked

1. Sequencing the monetization ladder

LangChain monetized in the order its users matured: free frameworks built the audience (2022–2023), observability monetized debugging once apps hit production (2024), deployment monetized hosting once agents ran long (2025), and Fleet/Engine/Sandboxes monetized the post-deployment lifecycle (2026). Each SKU landed roughly when the installed base developed the problem it solves. See how AI companies structure pricing.

2. Repricing to the buyer’s unit before scale locked it in

Swapping per-node for per-run billing in late 2025 fixed a forecasting flaw while the deployment business was still young. “What’s a node?” required reading your own graph; “what’s a run?” matches the metric every team already tracks. Doing it pre-scale avoided the grandfathering mess that haunts later repricings. Related: choosing the right usage metric.

3. Brand consolidation ahead of the bundle

Renaming LangGraph Platform to LangSmith Deployment (October 2025) looked cosmetic but was pricing infrastructure: it let the 2026 SKU wave (Fleet, Engine, Sandboxes) launch as line items on one familiar bill rather than as separate products to procure — and positioned Enterprise’s committed LangChain credits as a single drawdown pool across the whole stack. See outcome-based pricing trends.

Areas to improve : Gaps in LangChain’s pricing approach

1. No bundle math across seven meters

Each meter is individually transparent, but nothing on the page helps a buyer compose them: a team adopting Deployment + Fleet + Engine has to assemble seats, runs, uptime, traces, LCUs, and provider LLM costs by hand. An interactive whole-stack estimator would defuse the biggest objection — that the floor is $39 and the ceiling is unknowable. See bill shock and cost unpredictability.

2. The LCU is a trust ask

Engine’s unit blends compute, infrastructure, and model usage into a vendor-defined abstraction with usage published as estimates (“about 10 to 15 LCUs every 6 hours”). Without a published breakdown or per-run cap, cost-sensitive teams will simply keep Engine switched off — throttling adoption of the highest-margin product in the stack.

3. Idle-time economics for spiky agents

Uptime billing suits steady production traffic but punishes agents with bursty schedules — $155/month of standby for a deployment that fires nightly. Scale-to-zero or scheduled-sleep pricing for production deployments would close the gap with serverless competitors and remove a reason to self-host.

Key takeaways

1. Give away the name, sell the platform. LangChain’s frameworks are free marketing at planetary scale; every dollar flows through LangSmith — and the strategy survived the awkwardness of the paid brand differing from the company name.
2. Meters should match what buyers count. The node→run repricing traded a precise-but-opaque unit for a countable one, and rebalanced costs toward simple workloads to do it.
3. Stateful agents need two axes. Per-run fees price activity; uptime minutes price persistence. Long-running agent infrastructure increasingly looks like database pricing, not API pricing.
4. Each new SKU gets its own unit — watch the abstraction creep. Traces → runs → LCUs maps a drift from observable events to vendor-defined work units as products become more autonomous.
5. A stable seat anchor buys freedom on the usage axes. Holding $39/seat fixed since 2024 gave LangChain cover to add, rename, and reprice six usage meters without a single “price increase” headline.

UBP implications

1. Open-core AI infra monetizes the lifecycle, not the framework. The durable pattern — also visible at Helicone and across LLMOps — is a free core with paid meters attached to production pain: observability, deployment, and now autonomous maintenance.
2. Repricing early is cheaper than repricing late. LangChain swapped its deployment unit roughly eight months after GA, before large accounts anchored on per-node economics. Teams designing v1 meters should plan for one unit revision — and take it while the book of business is small.
3. Synthetic units (LCUs, credits) need published decomposition to scale. Blended units simplify invoices but shift forecasting risk to the buyer; the vendors that win with them pair the abstraction with hard caps, breakdowns, or committed-credit drawdown pools, as LangChain does on Enterprise. See usage-based pricing strategy.

Sources

• LangChain pricing page — live capture (accessed 2026-06-10)
• LangGraph Platform GA announcement, May 14 2025 (accessed 2026-06-10)
• LangChain changelog — LangSmith Deployment naming change (accessed 2026-06-10)
• Everything we shipped at Interrupt 2026 (accessed 2026-06-10)
• Fortune — LangChain $125M Series B at $1.25B valuation (accessed 2026-06-10)
• TechCrunch — LangChain hits $1.25B valuation (accessed 2026-06-10)
• Wikipedia — LangChain (founding, Benchmark seed, Sequoia Series A) (accessed 2026-06-10)
• Wayback Machine snapshots of langchain.com/pricing — 2024-07, 2025-07, 2025-11, 2026-01 (accessed 2026-06-10)

Bottom line

LangChain runs the cleanest open-core ladder in agent infrastructure: free frameworks (LangChain, LangGraph) built a planetary funnel, and the LangSmith platform monetizes it with a $39 seat anchor — unchanged since 2024 — plus seven usage meters spanning traces, deployment runs ($0.005), uptime minutes, Fleet runs ($0.05), Engine LCUs ($1.50), and per-second sandbox compute. The late-2025 node→run repricing made deployment forecastable, but the 2026 SKU wave pushes toward ever more abstract vendor-defined units, and composing the full bill across seven meters remains the buyer’s problem. For the observability half of the story, see the LangSmith blueprint.

Want to compare LangChain against other agent-infrastructure companies? Browse the pricing blueprint.

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.

Full agent-stack pricing verified — seven meters, one seat anchor

Jun 2026

Live capture: Developer $0 / Plus $39-seat / Enterprise custom, now spanning traces ($2.50–$5.00 per 1k), deployment runs ($0.005) + uptime, Fleet runs ($0.05 beyond 500/mo, rebranded from Agent Builder in March 2026), Engine at $1.50/LCU (Interrupt 2026 launch), and Sandboxes billed per second ($0.0576/vCPU-hr, $0.0185/GiB-hr memory, $0.000123/GiB-hr storage).

Deployment repriced — per-node-executed becomes $0.005 per run

Jan 2026

Wayback snapshots bracket a quiet metering change: November 2025 still shows $0.001 per node executed; by January 24, 2026 the page bills a flat $0.005 per deployment run (one end-to-end agent invocation — nodes and subgraphs no longer charged separately). Uptime minutes unchanged.

Series B unicorn round; LangGraph Platform renamed LangSmith Deployment

Oct 2025

LangChain raises $125M led by IVP at a $1.25B valuation and consolidates branding: LangGraph Platform becomes LangSmith Deployment and LangGraph Studio becomes LangSmith Studio, putting every paid SKU under the LangSmith umbrella. Headline prices unchanged ($39 seat, $0.001/node, standby minutes).

LangGraph Platform GA — per-node deployment pricing goes public

May 2025

LangGraph Platform reaches general availability with three deployment options (Cloud, Hybrid, Self-Hosted). Public metering: $0.001 per node executed plus standby uptime at $0.0036/min for production and $0.0007/min for development deployments; a free self-hosted Lite tier includes 100k nodes executed/month.

LangGraph Cloud beta — deployment as a product

Jun 2024

Alongside LangGraph v0.1, LangChain announces LangGraph Cloud in beta: managed infrastructure for deploying long-running, stateful agents. Deployment pricing is not yet on the public pricing page, which still shows only LangSmith seats and traces (Wayback, July 2024).

LangSmith GA — first paid SKU

Feb 2024

After a year of free open-source distribution (Oct 2022 launch, $10M Benchmark seed in April 2023), LangChain ships its first revenue line: LangSmith observability exits beta at $0 Developer / $39-seat Plus / custom Enterprise, the same month as the $25M Sequoia Series A (~$200M valuation).