LangSmith pricing

About

LangSmith is the commercial agent platform from LangChain — the company behind the eponymous open-source LLM framework (one of the most-starred AI projects on GitHub) and the LangGraph agent-orchestration library. It started as an observability and evaluation product — tracing, debugging, evals, and prompt/dataset management for LLM and agent applications — and works whether or not you build on the LangChain framework. As of mid-2026 the pricing page sells LangSmith as five metered services: Observability & Evals, Deployment, Fleet, Engine, and Sandboxes.

LangChain raised a $25M Series A in February 2024 (led by Sequoia, ~$200M valuation), the same month LangSmith reached general availability. In October 2025 it closed a $125M Series B led by IVP at a $1.25B valuation — minting it a unicorn — with strategic participation from Databricks, Datadog, Cisco, ServiceNow, and Workday. Revenue is widely understood to come primarily from LangSmith seats and trace usage plus LangGraph Platform deployments.

For current rates, see LangSmith’s pricing page.

Pricing summary : How LangSmith’s pricing model works

LangSmith is a hybrid model: a per-seat subscription that gates access, plus pay-as-you-go usage on everything the platform does. There are three tiers — Developer ($0 / seat per month, maximum 1 seat), Plus ($39 / seat per month, unlimited seats), and Enterprise (custom pricing, with self-hosted and hybrid deployment). Seats are the only flat charge on the page; every service meters on top.

The distinctive part is that all of that metering now runs through two normalized units rather than per-product dollar rates:

• LCU — LangChain Compute Unit, “for work done & compute”, priced at $1.50 / LCU.
• LSU — LangChain Storage Unit, “for traces & storage”, priced at $1.00 / LSU.

Every billable dimension resolves into one of those two units:

• Traces (Observability & Evals) — 0.005 LSU per base trace (14-day retention). Upgrading a trace to extended retention adds 0.0025 LSU. The pricing page puts the extended window at 180 days; LangSmith’s own billing and compliance docs still say 400, so treat the window as unsettled. Developer includes 5k base traces/mo, Plus includes 10k, then pay-as-you-go.
• Deployment — charged on resources consumed: runtime compute 0.045 LCU / vCPU-hr, runtime memory 0.006 LCU / GiB-hr, database compute 0.177 LSU / vCPU-hr, database memory 0.025 LSU / GiB-hr. Plus includes 1 free Serverless (Small) deployment.
• Fleet — metered in LCU, with 5 LCU/mo free on Developer and 25 LCU/mo included on Plus. Fleet pricing now includes the underlying model costs across three performance tiers (Fast, Pro, Max).
• Engine — metered in LCU; the pricing page puts a run at roughly 5–30 LCU (LangChain’s Engine docs say 30–40 LCU to initialize and 10–15 LCU per scan), scheduled every 6 hours. Plus only.
• Sandboxes — compute 0.0384 LCU / vCPU-hr, memory 0.0123 LCU / GiB-hr, storage 0.000123 LSU / GiB-hr, all billed per second. Both plans include 5 LCU & 1 LSU/mo free; Developer is capped at 10 sandboxes.

You don’t pick a retention class up front for every trace. Every trace incurs the base charge; a trace then auto-upgrades to extended when you add feedback, route it into an annotation queue, or an automation rule matches it. So the things that make observability useful — human review, eval scoring, automations — are exactly what adds the upgrade line.

What makes this different: most observability tools meter on a single event/span volume in dollars. LangSmith stacks two multipliers (seats × usage), bifurcates the trace axis by retention, and then abstracts every meter behind a compute/storage unit pair — closer to a cloud provider’s pricing sheet than to an observability SaaS’s.

Pricing by product

LangSmith platform (seats and plan entitlements)

Normalized usage units (all plans)

Observability & Evaluation (traces)

Deployment

Fleet, Engine and Sandboxes

Sales motions across products: self-serve / PLG for Developer and Plus (credit card, instant signup, monthly billing), sales-led for Enterprise (self-hosted, hybrid, custom retention, annual invoice, procurement and infosec review). A discounted LangSmith for Startups program offers reduced rates and credits for VC-backed startups via an application. For a primer on metering choices like these, see choosing the right usage metric.

Hidden costs : What LangSmith users actually pay

The sticker price ($39/seat) understates real bills because two axes compound. Worked example for a five-person team running a moderately busy multi-step agent on Plus, ~200k traces/month, retained for audit (extended):

The same team on the pre-July-2026 rates would have paid roughly $1,145. Three things bite teams that aren’t in the headline number:

1. Seat creep. Teams budget for 5 developer seats; then QA wants to inspect traces, PMs want to read failure cases, and data science wants to score outputs. A jump from 5 to 12 seats is +$273/mo nobody planned for.
2. The extended-retention upgrade. Every trace you add feedback to, queue for annotation, or hit with an automation rule silently moves from 0.005 to 0.0075 LSU — $5.00 to $7.50 per 1,000. High-eval workflows pay the upgrade on a large share of traffic.
3. Unit indirection. Because the page quotes LCU and LSU rather than dollars, a per-trace cost only appears after you multiply by $1.00/LSU — and the per-trace rate itself is disclosed only in a hover tooltip. Budgeting requires arithmetic the pricing page no longer does for you.

At scale the trace axis dominates. At the current 0.005 LSU base rate, ~500k base traces/mo runs ≈$2,450/mo in overage above the 10k Plus allowance, 1M ≈$4,950/mo, and 5M (not unusual for high-traffic agents) ≈$24,950/mo — before seats or extended-retention upgrades. Each of those figures is exactly double what the same volume cost before 2026-07-21.

Want to estimate your own LangSmith bill? Use the LangSmith pricing calculator to model seats and trace volume.

Pricing evolution : LangSmith pricing history and changes

Cadence

Tracked range: 2024 GA → 2026 Q3. Quarters not listed above were verified stable (0 price changes, 0 SKU additions). The $39/seat Plus price has never moved since launch; every repricing to date has landed on the usage axis — first the two-retention-class trace model and its auto-upgrade mechanic, then the July 2026 shift to normalized LCU/LSU units.

Notable changes

• 2024-02 — LangSmith reaches GA with the $0 / $39-seat / custom three-tier structure.
• 2025-10 — Series B; LangSmith folded into a broader observe-evaluate-deploy platform narrative; pricing mechanics unchanged.
• 2026-06 — Verified base $2.50/1k (14-day) and extended $5.00/1k (400-day) trace pricing.
• 2026-07-21 — LangSmith replaces every published usage rate with two normalized meters, LCU ($1.50, work and compute) and LSU ($1.00, traces and storage), and stops publishing dollar-per-1k trace rates on the page. Base traces are now 0.005 LSU and the extended upgrade 0.0025 LSU — an effective doubling of the base rate and a 50% rise on an all-in extended trace.
• 2026-07-21 — Extended retention shortens from 400 days to 180 on the pricing page, while the billing docs still say 400 — an unresolved contradiction between two live vendor surfaces.
• 2026-07-21 — Deployment and Fleet leave per-run pricing for resource metering; Fleet folds model costs into its Fast/Pro/Max tiers, and existing deployment customers are grandfathered until 2026-10-01.

The LCU/LSU repricing in detail

The July 2026 change is easy to misread as a re-denomination. It isn’t. LangSmith replaced dollar rates with unit rates across every product line at once, which normally makes a before/after comparison impossible — but the Sandboxes line pins the exchange rate. Sandbox compute moved from $0.0576/vCPU-hr to 0.0384 LCU/vCPU-hr, and 0.0384 × $1.50 = $0.0576 exactly; memory and storage convert cleanly too. Those lines are dollar-neutral, which means the published $1.50/LCU and $1.00/LSU are the real conversion factors and every other line can be read in old money.

Read that way, the trace axis moved sharply. A base trace went from $2.50 to $5.00 per 1,000 — a 100% increase on the single meter most LangSmith customers touch. The extended-retention upgrade held its effective $2.50/1k, so an all-in extended trace went from $5.00 to $7.50 per 1,000, up 50%. At the same time the extended-retention window was cut from 400 days to 180. On a per-trace-day basis — what you actually buy when you pay for retention — 1,000 extended traces went from $0.0125/day of retention to $0.0417/day, roughly a 3.3× move.

Two design choices soften the optics. Seats stayed at $0 and $39, so the number a buyer anchors on didn’t change; and the free tier got wider on the same day, with Sandboxes newly available on Developer (5 LCU + 1 LSU/mo, capped at 10 sandboxes). Meanwhile the per-trace rate itself is no longer stated in the page’s body copy — it lives in a hover tooltip on the feature table. A buyer comparing LangSmith to a usage-only rival now has to hover, convert, and multiply before the comparison is even possible.

The Deployment and Fleet changes are a separate move with a deadline attached. Both left per-run charges for resource metering, which shifts cost from “how often did it run” to “how much infrastructure did it hold” — better for bursty agents, worse for long-lived, lightly-used deployments. Scale-to-zero is only offered on the new model, which is the carrot; the stick is that grandfathering for existing deployment customers ends 2026-10-01. Anyone still on legacy deployment pricing should model both bills before that date rather than after.

What’s unique : LangSmith’s distinctive pricing mechanics

1. Two normalized meters instead of per-product prices. Since 2026-07-21, every billable thing LangSmith does resolves into an LCU ($1.50, work and compute) or an LSU ($1.00, traces and storage). That’s a cloud-provider convention, not an observability-SaaS one, and it does real work for the vendor: new products ship with a consumption factor rather than a new price list, and cross-product allowances (“5 LCU & 1 LSU/mo free”) become expressible in one sentence. The cost to the buyer is a layer of arithmetic between the page and the bill.

2. Two retention classes on the usage axis. Rather than one trace price, LangSmith splits billing into base (14-day, 0.005 LSU) and extended (180-day, +0.0025 LSU). Retention — usually a backend concern — is the primary usage price lever, and the July 2026 change moved both halves of it at once: the base rate doubled and the extended window shrank by 55%.

3. Auto-upgrade on engagement. A trace jumps from base to extended the moment you add feedback, annotate it, or an automation matches it. The pricing literally tracks which traces you care about, monetizing the high-value subset. Because the upgrade is triggered by workflow rather than chosen up front, the share of traffic hitting the higher rate is a consequence of how your team works, not a setting you pick.

4. Two compounding multipliers. Seats gate access; usage meters everything else. Both grow with team adoption, so cost scales on adoption and traffic simultaneously — generous to a solo developer (free, now including Sandboxes), expensive for a busy production team.

Strengths & weaknesses

Billing UX : LangSmith billing controls and transparency

• LangSmith Usage Calculator — a pre-purchase estimator on the pricing page itself. You pick products (“your agent stack”: Observability & Evals, Engine, Deployments, Sandboxes, Fleet), set traces/month and seat count, and it returns a monthly total broken out into LCU and LSU subtotals. It also has a Copy Estimate Link button so a buyer can share the estimate internally. The page labels it “Estimate only. Actual LCU/LSU consumption varies with the work your agents perform.”
• Spend limit per workspace — under Settings → Billing and Usage → Usage limits you enter a dollar spend limit and LangSmith derives matching base and extended trace limits (free plan traces are folded into the first workspace’s calculation). Workspace-level limits are approximate on multi-workspace orgs; the organization-level limit is absolute.
• Trace tier distribution — a “Default data retention” setting per workspace (Base or Extended) plus a slider distributing your trace limits across the two tiers, with a LangSmith-suggested split you can override. Optionally applies retroactively to existing traces via a checkbox. Note the side effect the docs flag: hitting the extended-retention limit can stop non-tracing features from working.
• Project-level retention + automation rules — retention is also settable per tracing project (base 14-day vs extended), and an automation rule can upgrade a filtered percentage of traces (e.g. 10% of all traces, or all errored traces) to extended retention.
• Usage visibility — Settings → Billing shows organization LCU usage, and the docs expose usage graphs, granular usage, invoices and (Enterprise) prepaid contract-consumption tracking. Usage is measured per workspace.
• Billing cadence — Developer and Plus seats bill monthly on the 1st, pro-rated if added mid-month, with no credit for removed seats; traces bill monthly in arrears. Enterprise is invoiced annually upfront.
• Payment and procurement — credit card self-serve for Developer/Plus (invoice email, business name/address and tax ID are editable for tax exemption); annual invoice, custom terms and infosec review on Enterprise. Data location is LangChain’s Cloud (US or EU) on Developer/Plus.
• Grandfathering on the new model — the docs state that the resource-based Deployment model “replaces the previous per-run and uptime pricing,” and that existing customers stay on their current pricing until October 1, 2026. Scale-to-zero is only available on the new pricing. The Fleet docs give the same deadline from the other side: the new model tiers and LCU pricing apply to Fleet usage started on or after July 15, 2026, while organizations already on Fleet keep their existing setup until October 1, 2026 — and any organization with grandfathered Plus seat or trace pricing keeps those rates through that transition.
• Engine kill switch — an Organization Admin can turn Engine off in Settings, which stops its 6-hourly runs and its LCU consumption.

Strategic wins : Why LangSmith’s pricing decisions worked

1. A free tier that rides an enormous OSS funnel

LangChain’s framework brought millions of developers; the free Developer tier converts that distribution into LangSmith signups with near-zero friction. The OSS framework is the top of the funnel, LangSmith is the monetization layer. The July 2026 repricing widened the mouth of that funnel at the same moment it raised paid rates — Sandboxes became available on Developer with a 5 LCU + 1 LSU monthly allowance, and Fleet got a 5 LCU free tier. See how AI companies structure pricing.

2. Normalizing every meter into two units

The 2026-07-21 move to LCU and LSU is the most consequential pricing decision LangSmith has made since GA. It collapses five products with five different natural units — traces, deployment runs, vCPU-hours, GiB-hours, Engine runs — into one compute price and one storage price. Operationally that means the next product ships with a consumption factor instead of a pricing negotiation, and committed-spend contracts on Enterprise become a single credit pool rather than per-SKU commitments. Related: choosing the right usage metric.

3. Metering on retention, not just volume

By charging more for the traces you keep around (and care about), LangSmith aligns price with value — the traces feeding evals and audits are the ones worth paying for. The July 2026 cut from 400-day to 180-day extended retention also quietly aligns the price with LangSmith’s own storage cost curve, since the long tail of a 400-day window is rarely read. Related: usage invoicing and billing cycles.

4. Raising the usage axis while holding the seat anchor

The July 2026 change doubled the base trace rate but left Plus at $39/seat and Developer at $0 — the two numbers buyers quote to each other and screenshot into decks. Holding the anchor while repricing the elastic axis is a deliberate, well-worn move: the headline stays comparable year over year, the increase lands where usage growth already made bills variable, and the new unit denomination means no customer sees a familiar dollar figure change. It works commercially; it costs trust with the subset of buyers who do the conversion. See outcome-based pricing trends.

Areas to improve : Gaps in LangSmith’s pricing approach

1. Seat tax on the wrong people

Charging $39 for every QA tester, PM, or analyst who just wants to read traces pushes teams to ration access — the opposite of what an observability tool should encourage. A cheaper read-only seat would defuse the most common complaint. See bill shock and cost unpredictability.

2. A hover tooltip is not price disclosure

Since 2026-07-21 the per-trace rate — the number almost every LangSmith buyer needs — appears only in a tooltip on the feature table. Everything else on the page is denominated in LCU and LSU, so answering “what does a trace cost?” requires hovering, then multiplying by $1.00/LSU. The fix is small and costs the vendor nothing: print the dollar-equivalent next to each unit rate, the way cloud providers print per-hour dollars next to instance specs. Leaving it hidden reads as an attempt to make a 2× increase hard to notice. See bill shock and cost unpredictability.

3. Two live surfaces contradicting each other on retention

The pricing page says extended traces are retained 180 days; the billing docs still say 400. That’s not a rounding difference — it’s a 220-day gap on the exact attribute a buyer is paying extra for, and it landed with the repricing. Whichever number is correct, the other one needs to change today, because a compliance-driven buyer will make a retention commitment on the wrong one.

4. Hard-to-forecast extended-retention upgrades

Because traces upgrade automatically on feedback, annotation, or automation match, teams can’t predict what fraction of traffic will hit the 0.0075 LSU all-in rate. The new usage calculator estimates by product but still asks the buyer to guess the base/extended split. Deriving that split from the workspace’s own historical upgrade rate — LangSmith already has the data — would turn a guess into a forecast.

5. Price gap vs. usage-only rivals at scale

Langfuse and similar tools undercut LangSmith dramatically for high-volume teams with no per-seat multiplier, and doubling the base trace rate on 2026-07-21 widened that gap rather than narrowing it. At 1M traces/mo the trace line alone is now ≈$4,950/mo before seats. The seat tax plus a doubled base rate makes migration arithmetic easy for cost-sensitive buyers to run.

Key takeaways

1. Two units now carry the whole usage axis. Since 2026-07-21, LCU ($1.50, work and compute) and LSU ($1.00, traces and storage) price all five products on top of a per-seat subscription. It reads like a cloud bill, not an observability invoice.
2. The re-denomination was a price rise. Sandbox rates convert back to their old dollar values exactly, which pins the conversion factors and shows base traces doubled to an effective $5.00/1k and all-in extended traces rose 50% to $7.50/1k — while extended retention fell from 400 days to 180.
3. Retention is still the price lever. Base (14-day, 0.005 LSU) vs extended (180-day, +0.0025 LSU), with traces auto-upgrading the moment they earn feedback or annotation, so the share of traffic at the higher rate follows how your team works.
4. Two multipliers compound. Real bills scale with seats and usage, so a tool that’s free for a solo dev gets expensive fast for a production team — a five-person, 200k-trace team now models at roughly $1,620/mo versus about $1,145 before.
5. The OSS funnel widened as prices rose, but scale still invites defection. Developer gained Fleet and Sandbox allowances on the same day paid rates went up; at high trace volumes per-usage rivals remain several-fold cheaper, and the July 2026 increase made that comparison more favourable to them.

UBP implications

1. Normalized units are the right answer to multi-product metering — and a transparency liability if you stop there. Collapsing five products into a compute unit and a storage unit is genuinely good engineering of a price list: it makes allowances, commitments and new SKUs expressible without renegotiation. But a unit is only as legible as its dollar translation, and LangSmith’s July 2026 page prints the unit price everywhere and the dollar-per-trace nowhere. If you adopt this pattern, publish both.
2. Re-denomination is the easiest way to move a price, which is exactly why buyers should audit it. LangSmith kept its sandbox rates dollar-neutral, which is what made the trace increase provable. Vendors changing units should expect that arithmetic to be done; buyers should do it before renewal rather than after.
3. An OSS top-of-funnel plus a usage-metered commercial layer is a durable AI-infra pattern — but the paid metric has to stay defensible. Doubling that metric while cheaper single-axis rivals hold is how a distribution advantage gets spent. The same discipline applies to the seat axis: when the people who need read access aren’t the people generating value, seat pricing discourages the adoption you want, and to the retention window itself, which LangSmith’s own surfaces currently state as both 180 and 400 days.

Sources

• LangSmith / LangChain pricing page (accessed 2026-07-21)
• LangSmith billing & usage docs (accessed 2026-07-21)
• LangSmith administration overview (accessed 2026-07-21)
• LangSmith Engine docs — understand LCU costs (accessed 2026-07-21)
• LangSmith Fleet essentials — LangChain Compute Units (accessed 2026-07-21)
• LangSmith data purging & compliance — extended retention policy (accessed 2026-07-21)
• LangChain blog — Series B announcement (accessed 2026-06-09)

Bottom line

LangSmith monetizes LangChain’s enormous open-source distribution with a clean hybrid model: a free Developer tier, a stable $39/seat Plus plan, and usage metered — since 2026-07-21 — in two normalized units, LCU ($1.50) for compute and LSU ($1.00) for storage. The unit model is good pricing architecture and bad price disclosure: it lets five products share one price list, but it moved the per-trace rate into a hover tooltip on the same day that rate doubled to an effective $5.00 per 1,000 and extended retention shrank from 400 days to 180. Seats didn’t move, so the number buyers anchor on looks unchanged while the elastic axis absorbed the increase. The design still aligns price with value — you pay more for the traces you keep and review — but two compounding multipliers plus an auto-upgrade mechanic make bills hard to forecast, and at scale the arithmetic now points more clearly than before toward cheaper usage-only rivals.

Want to compare LangSmith against other LLM observability and MLOps 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.

Usage axis repriced into LCU/LSU normalized units

Jul 2026

LangSmith replaced its published dollar-per-1k trace rates and Deployment/Fleet per-run pricing with two normalized meters: LangChain Compute Units (LCU, $1.50) and LangChain Storage Units (LSU, $1.00). Base traces are now 0.005 LSU each (double the prior $2.50/1k), the extended-retention upgrade is 0.0025 LSU, and extended retention shortened from 400 days to 180. Deployment and Sandboxes moved to resource metering; Fleet moved from per-run to LCU and now includes model costs. Seats unchanged at $0 / $39. Existing deployment customers grandfathered until 2026-10-01.

Pricing verified — two-retention-class trace billing confirmed

Jun 2026

Live verification: Developer $0 (1 seat, 5k base traces), Plus $39/seat (10k base traces), Enterprise custom. Base traces $2.50/1k (14-day), extended $5.00/1k (400-day), upgrade +$2.50/1k.

LangChain Series B — $125M at $1.25B valuation

Oct 2025

LangChain becomes a unicorn (IVP-led round) and repositions LangSmith inside a broader 'agent engineering' platform spanning observability, evaluation, and deployment. Pricing structure (seats + per-trace, two retention classes) carried forward.

LangSmith reaches general availability

Feb 2024

LangSmith exits beta and becomes generally available, debuting the Developer (free) and Plus ($39/seat) self-serve tiers alongside Enterprise. Launched the same month as LangChain's $25M Series A at a $200M valuation (Sequoia).