LangSmith Pricing Explained (2026): Traces, Seats & Alternatives

LangSmith pricing at a glance (June 2026)

LangSmith pricing looks simple on the surface: a free Developer plan, a Plus plan at $39 per seat per month, and a custom-priced Enterprise tier. The complexity hides one layer down, in trace-based billing. Your monthly bill is driven by how many traces your application emits and how long you keep them, and trace volume scales with how chatty your agent is, not with how much value it produces. That's why one of the top search results for LangSmith pricing is a Reddit thread asking what "10k free traces" actually buys.

This guide explains the mechanics with numbers verified against the official pricing page in June 2026, works through three realistic monthly bills, flags the gotchas honestly, and compares the alternatives. One warning up front: LangSmith's trace prices changed, and many third-party guides still cite the old $0.50 per 1k base trace price. The current official price is $2.50 per 1k. If a guide you're reading says otherwise, it's stale.

Here's the short version. LangSmith's Developer plan is free for one seat with 5k base traces per month included. Plus costs $39 per seat per month with 10k base traces included. Beyond the included allowance, base traces (14-day retention) cost $2.50 per 1k and extended traces (400-day retention) cost $5.00 per 1k. Enterprise pricing is custom.

Overages on both self-serve plans: $2.50 per 1k base traces (14-day retention), $5.00 per 1k extended traces (400-day retention); upgrading base to extended costs an additional $2.50 per 1k. Developer organizations are capped at 5k traces/month until a credit card is added. Verified against the official pricing page, June 2026.

What's actually free

The Developer plan gives you one seat and 5,000 base traces per month, and per the billing documentation, personal organizations are hard-capped at 5,000 traces per month until you add a credit card. Those traces live for 14 days. For a solo developer prototyping an agent, that's genuinely useful: you can debug a few thousand runs a month without paying anything. What it is not is a production observability budget. A modest production agent burns through 5,000 traces in a day or two, and the 14-day window means nothing you capture today will be around for next quarter's eval dataset.

One scoping note: the LangChain pricing page now covers far more than observability. The same invoice can carry deployment runs at $0.005 each, deployment uptime by the minute, Fleet runs, and Engine compute. This guide covers the observability meters: seats, traces, and retention. If you adopt the broader platform, budget for those other lines too.

Read time: 12 minutes

How LangSmith trace-based billing works

The billing unit that matters is the trace, and most sticker shock comes from misunderstanding what one is.

What counts as a trace

LangSmith defines a trace as a single execution of your application — an agent run, an evaluator run, or a playground session — which can contain many individual steps such as LLM calls and other tracked events. A trace is not an LLM call. One agent run that makes 15 model calls and 10 tool calls is one trace containing 25-plus steps. If you're unsure what belongs inside that execution, our guide to what a production agent trace should contain walks the anatomy field by field.

Two consequences follow. First, the included allowances (5k on Developer, 10k on Plus) go further than "10k LLM calls" would suggest, because a trace bundles many calls. Second, anything that triggers an execution bills as a trace — including evaluation runs. Run a nightly eval over a large dataset and every example generates a billable trace.

Base vs. extended retention

Every trace lands in one of two retention tiers, and the tier sets the price:

• Base traces: 14-day retention, $2.50 per 1k traces.
• Extended traces: 400-day retention, $5.00 per 1k traces.
• Upgrades: converting a base trace to extended costs an additional $2.50 per 1k.

The included monthly allowances are base traces. Extended retention is 400 days by default and customizable for Enterprise customers.

The retention choice is a real decision, not a checkbox. Fourteen days is fine for live debugging: something broke this week, you look at this week's traces. But the moment you want to build eval datasets from production traces, audit past behavior, or assemble fine-tuning data, you need traces that survive longer than two weeks, and that doubles the per-trace price.

This is exactly the confusion behind the r/LangChain thread asking whether "10k free traces" are equivalent to about 1k extended traces. The honest answer under current pricing: the included traces are base-tier, switching your project default to extended retention means overages bill at the extended rate, and the upgrade path costs another $2.50 per 1k on top of what you already paid.

Why agents generate more traces than you expect

Here's the part no calculator widget tells you: your trace count is a function of where your instrumentation starts a new top-level execution, not of your traffic.

Figure 1: Where the LangSmith trace meter attaches — the trace boundary your instrumentation chooses sets billed volume; each trace then bills at its retention tier's rate, with seats and eval runs on top.

Consider a support agent handling 50,000 user sessions a month. Instrument it so each session is one execution and you emit 50,000 traces. Instrument it so each conversation turn starts a new execution — a common default when each turn is a separate request handler — and a six-turn average session emits 300,000 traces. Same users, same model spend, same business value, six times the billable volume. LangSmith's definition leaves this boundary up to your code, which means two teams with identical traffic can see bills that differ by a multiple.

Worked examples: three realistic monthly bills

The arithmetic below uses the current unit prices — $39 per seat, $2.50 per 1k base traces, $5.00 per 1k extended traces — so you can swap in your own numbers. All bills are estimates of the observability meters only.

Prototype on the Developer plan

One developer, one prototype agent, roughly 3,000 traces a month. Seats cost $0 and the volume sits inside the 5,000 included base traces, so the bill is $0. Push to 8,000 traces and you'd pay for 3,000 overage traces: 3,000 × $2.50/1k = $7.50 a month. The free tier really does cover prototyping, which is why so many teams start here.

Mid-scale agent on Plus

A team of five running an agent that handles 50,000 sessions a month, instrumented as one trace per session, each trace containing about 15 LLM calls:

• Seats: 5 × $39 = $195
• Trace overage: 50,000 − 10,000 included = 40,000 × $2.50/1k = $100
• Estimated total: about $295/month at base retention.

Want those traces around longer than 14 days, say to build eval datasets? At the extended rate the same overage costs 40,000 × $5.00/1k = $200, for a total around $395/month.

Now the verbosity trap. Re-instrument that same agent to start a trace per conversation turn (six turns per session on average) and volume jumps to 300,000 traces: 290,000 × $2.50/1k = $725 in overage, plus $195 in seats. That's about $920/month for identical traffic.

High-volume production on Plus

Ten seats and 500,000 traces a month:

• Seats: 10 × $39 = $390
• Base overage: 490,000 × $2.50/1k = $1,225
• Estimated total: about $1,615/month, or roughly $2,840/month if everything needs extended retention (490,000 × $5.00/1k = $2,450).

And evals compound it: a nightly eval over a 2,000-example dataset adds about 60,000 traces a month, around $150 more at the base rate, because evaluation runs generate billable traces.

Assumptions: Developer plan for the prototype, Plus for the rest; "per-turn" re-instruments the same 50k sessions at six conversation turns per session. Estimates exclude deployment, Fleet, and Engine meters.

For calibration: the only other worked numbers in the top search results, from Metacto's guide, land at about $670/month for five engineers with 200k traces and about $3,255/month for twenty engineers with 1M traces. Those are consistent with the math above. They just don't model the instrumentation granularity and retention-mix decisions that move the number most.

Gotchas and hidden costs

Six things that surprise teams after they've signed up:

1. The free tier has a hard gate. Personal organizations stop ingesting at 5,000 traces a month until a credit card is on file. Your traces don't queue; the cap is the cap.
2. Retention is a pricing decision you make per trace. Keeping data long enough to be useful for eval datasets or audits moves you from $2.50 to $5.00 per 1k, and upgrading after the fact costs another $2.50 per 1k.
3. Eval runs bill as traces. Frequent evaluation over large datasets is a real line item, not a rounding error; the nightly-eval example above adds ~$150/month by itself.
4. Seats scale with headcount, not usage. Twenty people who occasionally look at dashboards cost $780 a month before a single trace overage.
5. Trace counts follow instrumentation granularity. As the worked examples show, the same traffic can bill at a 6x multiple depending on where executions start.
6. Stale third-party numbers understate the bill. Guides citing $0.50 per 1k base traces describe the old pricing; the current official price is five times that.

Is LangSmith open source?

No. LangSmith is closed-source SaaS. Self-hosting exists, but only as a hybrid or self-hosted deployment on the custom-priced Enterprise plan. If "open source" or "self-host without an enterprise contract" is on your requirements list, you're looking at a different tool. Langfuse and Arize Phoenix are both open source and free to self-host, and both appear in the comparison below.

When LangSmith pricing makes sense — and when it doesn't

A fair read of the model: LangSmith is priced well for some teams.

It makes sense when you're all-in on LangChain or LangGraph and want observability that's native to the framework; when your trace volume is modest relative to your team size, so the $39 seat price dominates and stays predictable; or when you want the bundled platform (evals, playground, deployments) on one invoice. At low volumes, $39 per engineer is cheap compared to the hours it saves.

It makes less sense when you run high-volume agents and per-trace overage dominates the bill; when you need long retention as a default rather than an exception, because extended retention doubles the trace price; when your stack isn't LangChain-based and you'd rather standardize on OpenTelemetry; or when you wanted open source or self-hosting without an Enterprise contract.

If you're in that second group, here's what the alternatives actually look like in mid-2026.

LangSmith alternatives compared

The most important thing to understand about this market: every vendor bills a different unit. LangSmith bills traces. Langfuse bills units, where every span and score counts individually. Braintrust bills gigabytes and scores. Helicone bills requests. Catalyst bills spans. Comparing sticker prices without normalizing the unit is how teams get surprised twice.

Langfuse is the open-source default. Self-hosting is free, and the cloud tiers are Hobby (free, 50k units/month, 30-day data access, 2 users), Core at $29/month, Pro at $199/month, and Enterprise at $2,499/month, with unlimited users on every paid tier. Watch the unit definition: a billable unit is any tracing data point — traces, observations, and scores all count, so a 25-span trace consumes 25 units. Langfuse was acquired by ClickHouse in January 2026; the open-source project remains actively maintained.

Arize Phoenix is open source, free to self-host, and built on OpenTelemetry and OpenInference conventions. The managed Arize AX tiers run from a free plan (25,000 spans/month, 15-day retention) to Pro at $50/month. If you want zero-dollar self-hosted tracing and don't mind operating it, Phoenix is the benchmark.

Braintrust comes at the problem evals-first. Pricing is usage-based with unlimited users: the free Starter tier includes 1 GB of processed data, 10,000 scores, and 14-day retention; Pro is $249/month with 5 GB, 50k scores, and 30-day retention. Strong if systematic evaluation is your center of gravity; retention windows are short at every tier.

Helicone is a gateway-style request logger: Hobby free at 10,000 requests/month, Pro at $79/month, Team at $799/month. The honest caveat: Helicone was acquired by Mintlify in March 2026 and the cloud product is in maintenance mode — security updates and fixes keep shipping, but it's hard to recommend adopting fresh for a multi-year observability bet.

Catalyst (by inference.net) is OpenTelemetry and OpenInference-shaped tracing with per-span pricing and large allowances: the free tier includes 1M spans and 50 GB of span data a month, Starter is $25/month for 10M spans, and Growth is $250/month for 50M, with no per-seat charge on the observability meters; see Catalyst's pricing page for the current tiers. Because the unit is the span rather than the trace, a verbose agent doesn't change your unit economics. 1M spans covers the mid-scale scenario above many times over.

A Langfuse unit is any tracing data point (trace, observation, or score), so one multi-span trace consumes many units. Helicone's cloud has been in maintenance mode since the March 2026 Mintlify acquisition. Prices verified June 2026.

How Catalyst differs: from per-trace bills to fix-ready findings

The structural difference isn't the price list. LangSmith's model charges you to store traces that a human will inspect one at a time. That's the right shape for debugging a prototype. It breaks down in production, where the volume that drives your bill is also far too large for anyone to read.

Catalyst assumes that from the start. The tracing SDKs capture full execution detail (message history, tool calls with arguments and results, model and token metadata, errors) as OpenInference-shaped OpenTelemetry spans, with 16 documented integrations from OpenAI and Anthropic to LangChain, LangGraph, and the Vercel AI SDK; the full capture surface is in what Catalyst Tracing captures.

Then Halo does the reading. Halo is an open-source analysis engine that consumes spans across many runs, decomposes them to find systemic failure modes, and returns a ranked list of findings with citations back to specific trace IDs. You can run it on demand or put it on a schedule (hourly, daily, weekly, or monthly, each run reviewing up to a 30-day window) via Halo's scheduled cross-run analysis. Instead of paying per trace for the privilege of manual inspection, the traces become input to an automated loop: capture, analyze, fix, re-run.

The same data feeds forward. The Catalyst Gateway, which is independent of tracing, records one entry per LLM request with cost, latency, and token counts at under 10ms of overhead, and that recorded traffic powers downstream evaluation and model training. Traces stop being a storage bill and become the raw material for evals and fine-tuning.

Migrating from LangSmith to Catalyst

LangSmith already speaks OpenTelemetry, which makes evaluation low-risk. Catalyst bridges LangSmith OTel spans into its own tracer provider: set LANGSMITH_TRACING=true and LANGSMITH_TRACING_MODE=otel, and your existing traceable functions keep working while spans stream to Catalyst. The full walkthrough is in the LangSmith bridge guide.

Install the bridge alongside your existing code:

# Install the tracing SDK with the LangSmith extra
pip install 'inference-catalyst-tracing[langsmith]'

# Hybrid mode: keep LangSmith tracing active while also
# routing OpenTelemetry spans through Catalyst.
export LANGSMITH_TRACING=true
# Catalyst sets LANGSMITH_TRACING_MODE=hybrid when unset.

The hybrid default is the part that de-risks the evaluation: if LANGSMITH_TRACING=true is set and you don't set a tracing mode, Catalyst defaults LangSmith to hybrid mode, which keeps your existing LangSmith tracing active while also routing OpenTelemetry spans through Catalyst. You compare both backends on live production traffic, with nothing dropped, before deciding anything.

Your application code barely changes. A LangSmith traceable function under the bridge looks like this:

import os

from inference_catalyst_tracing import setup
from langsmith import Client, traceable

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_TRACING_MODE"] = "otel"

tracing = setup(service_name="langsmith-worker")
client = Client()

@traceable(name="answer_question", run_type="tool", client=client, enabled=True)
def answer_question(question: str) -> str:
    return question.upper()

print(answer_question("hi"))
client.flush()
tracing.shutdown()

One addition worth making during the switch: wrap your agent's run boundary in agent_span with a stable agent ID, as described in the agent identity guide. LangSmith spans stay visible underneath it, and the stable ID is what lets the Agents dashboard group runs across deploys and gives Halo a coherent run history to analyze.

That's the whole switch: a package install, two environment variables, and an optional span wrapper. If you want to see your own agent's traces before changing anything else, the quickstart takes a few minutes.

FAQ

How much does LangSmith cost? Developer is free (1 seat, 5k base traces/month). Plus is $39 per seat per month with 10k base traces included. Overages run $2.50 per 1k base traces and $5.00 per 1k extended traces. Enterprise is custom.

Is LangSmith free? For one developer and up to 5,000 base traces a month, yes, with a 5k/month hard cap until you add a credit card.

Is LangSmith open source? No. Self-hosting is available only through Enterprise hybrid/self-hosted deployments.

What's the difference between base and extended traces? Retention and price: base traces last 14 days at $2.50 per 1k; extended traces last 400 days at $5.00 per 1k, with 400 days customizable on Enterprise.

Do evaluation runs count toward billing? Yes. Evaluation runs generate billable traces, so frequent evals over large datasets add materially to monthly trace volume.

Did LangSmith pricing change from 2025? Yes. Older guides cite $0.50 per 1k base traces; the official pricing page now lists $2.50 per 1k base and $5.00 per 1k extended.

Conclusion

LangSmith pricing comes down to three numbers: how many traces your instrumentation emits per month (granularity × sessions), what fraction needs more than 14 days of retention, and how many seats you carry. Multiply those out before you commit, because each one compounds the others. Then ask the more interesting question: do you want to pay to store traces a human will inspect, or to have the whole volume analyzed automatically?

If the second option sounds like the better deal, Catalyst's free tier is sized so you can find out with a real production agent before paying anything.

Related Reading

• LLM Tracing: What to Capture in Production Agents — the trace-anatomy companion to this pricing guide
• Agent Observability Guide — the broader practice you're budgeting for
• LLM Evaluation Tools Comparison — adjacent comparison covering LangSmith and Braintrust as eval tools