Pricing Comparison
Understand LangSmith's pricing tiers so you can pick the right observability tool for your stack and budget.
Pricing information sourced from LangSmith's public documentation as of 2026.
| Developer | Plus | Enterprise | |
|---|---|---|---|
| Price | Free | $39/seat/mo | Custom |
| Seats | 1 | Unlimited | Unlimited |
| Traces/month | 5,000 | 100,000 included ~$0.50/1K extra |
Custom |
| Data retention | 14 days | 400 days | Custom |
| Support | Community | Dedicated | |
| Evaluations | Basic | Full | Full + custom |
| Custom dashboards | No |
The Developer tier is free: 5,000 traces per month, 14-day retention, one seat, basic evaluations, community support. Fine for prototyping with LangChain or LangGraph. Not usable for teams or production workloads.
The Plus tier at $39/seat/month is where most production teams land. You get 100,000 traces included, with overage at roughly $0.50 per 1,000 traces. Retention extends to 400 days, you get full evaluations, custom dashboards, and email support. Per-seat pricing means costs scale linearly — a team of 10 is $390/month before trace overage.
The Enterprise tier is custom-priced and adds dedicated support, custom retention policies, SSO, and higher trace volumes. LangSmith doesn't publish Enterprise pricing publicly.
One detail worth noting: LangSmith's trace counts include every run within a chain, not just top-level calls. A single agent invocation that calls a retriever, runs a prompt, and makes a tool call can generate multiple traces. When estimating which tier you need, count traces at the chain level, not the request level.
| Feature | LangSmith | Langfuse | Helicone | MarginDash |
|---|---|---|---|---|
| Prompt tracing | No | |||
| Cost tracking | Basic | |||
| Revenue/margin per customer | No | No | No | |
| Cost simulator | No | No | No | |
| Stripe integration | No | No | No | |
| Budget alerts | No | No | ||
| Self-hostable | No | OSS | No | No |
| Pricing | From $39/seat | Free (OSS) / Cloud paid | Free / paid tiers | Free and paid tiers |
LangSmith's pricing has two scaling dimensions: seats and traces. Seat cost is straightforward — $39 per user per month on Plus. A team of 5 pays $195/month in seat costs alone. A team of 15 pays $585/month. A team of 30 pays $1,170/month. All before a single trace is logged.
Trace cost is where things get less predictable. Plus includes 100,000 traces per month, with overage at roughly $0.50 per 1,000. At 500,000 traces/month, overage comes to about $200/month on top of seats. At 1 million traces, overage hits $450/month. At 5 million — not unusual for high-traffic apps with multi-step agents — you're paying roughly $2,450/month in trace overage alone.
For high-volume production apps, trace cost can quickly exceed seat cost. A team of 5 generating 2 million traces/month would pay $195 in seats plus roughly $950 in trace overage — $1,145/month total. This is the point where teams start evaluating whether they need to trace every run or whether sampling would be sufficient.
LangSmith lets you filter which runs get traced, but there's a tension: the whole point of observability is comprehensive visibility. Once you start sampling, you risk missing the trace that would have helped debug a production issue.
The Developer plan gives you 5,000 traces per month at no cost. In practice, the limit is tighter than it appears. A single LangChain agent run with tool calls and retrieval steps can generate multiple traces. Development workflows involving rapid iteration — change a prompt, run a test, check the trace, repeat — consume traces faster than most developers expect. A few hundred test runs can burn through the monthly allowance in a single session.
The 14-day data retention is the other significant constraint. Two weeks of history means you can debug recent issues but can't compare against a baseline from last month. If a user reports a problem and it takes more than 14 days to investigate, the relevant traces are gone. For production applications, the Developer tier is a trial, not a foundation.
The single-seat limitation makes the free tier strictly a solo tool. You can't invite a teammate to look at a trace or collaborate on evaluations. For anyone building with a team — even a team of two — you need Plus from day one, which means $78/month minimum before any trace overage.
Solo developer. The free Developer tier covers most solo use cases during prototyping. You get 5,000 traces, basic evaluations, and 14-day retention. Once you need production observability with longer retention, Plus at $39/month is reasonable for a single seat.
Small team (3-5 developers). A team of 5 pays $195/month for seats. Add typical trace volumes of 200,000/month and you're looking at an additional $50 in overage, bringing the total to roughly $245/month. This is LangSmith's sweet spot — small enough that per-seat pricing doesn't hurt, large enough that you need collaboration features and long retention.
Mid-size team (10-20 developers). Per-seat pricing starts to bite. A team of 10 pays $390/month in seats; a team of 20 pays $780/month. Production trace volumes at this scale are often 500,000 to 2 million per month, adding $200 to $950 in overage. A team of 20 generating 1 million traces/month pays roughly $1,230/month. At this point, teams often restrict LangSmith seats to developers who actively need trace access rather than giving the whole org access.
Enterprise (50+ developers). You're almost certainly on custom Enterprise pricing with negotiated per-seat rates, custom trace volumes, SSO, and dedicated support. LangSmith doesn't publish these numbers.
LangSmith is great if you're building with LangChain or LangGraph and need to debug prompt chains, trace agent behavior, and evaluate output quality. It's an engineering tool — built for the development and testing loop, not for the finance side of running AI in production.
Where LangSmith falls short is unit economics. It can estimate cost per trace from token counts, but it has no concept of revenue, margin, or customer profitability. It won't tell you which customers are underwater, connect to Stripe, or show what happens to margins if you swap GPT-4o for a cheaper model.
If you need both, they complement each other. Use LangSmith for debugging agents and evaluating quality. Use MarginDash for tracking what those agents cost per customer and whether revenue covers it.
LangSmith also makes less sense if you're not using LangChain. The standalone SDKs work, but instrumentation is more manual and you lose automatic tracing. If your stack uses direct API calls to OpenAI, Anthropic, or Google, a lighter-weight proxy like Helicone may be a better fit for observability, while MarginDash handles cost and margin tracking.
LLM observability and cost tracking get lumped together because they both involve monitoring API calls, but they answer different questions. Observability answers: What did my LLM calls do? Did the agent follow the right steps? Where did the chain fail? Cost tracking answers: How much did that customer cost me? Does revenue cover the AI spend? What if I swapped to a cheaper model? The first is an engineering question. The second is a business question that requires connecting costs to revenue.
The confusion arises because observability tools show cost estimates alongside traces. But knowing a trace cost $0.03 is very different from knowing that Customer X generated $49 in revenue and consumed $31 in AI costs, leaving a 37% margin. The first is a data point. The second is actionable — adjust pricing, set usage limits, or swap models.
Most production teams serious about both quality and profitability use tools from both categories: an observability tool like LangSmith, Langfuse, or Helicone for debugging, and a cost tracking tool like MarginDash for per-customer economics.
The subscription price is the most visible cost, but not the only one. Engineering time is the biggest hidden expense — setting up tracing, configuring which runs to log, building evaluation datasets, writing custom evaluators, and maintaining integrations as your app evolves. For a mid-size team, initial setup and ongoing maintenance can consume a full engineering week per quarter.
There's also the compliance surface area. Every traced call sends input prompts, output responses, token counts, and metadata to LangSmith's servers. For applications handling sensitive data, your security team may require additional due diligence, data processing agreements, or content filtering before traces are sent.
Finally, observability can become a cost center that nobody re-evaluates. Teams set up tracing during development when they need deep visibility. Once the application stabilizes, the same level of tracing continues in production — generating traces and adding to the monthly bill — without anyone asking whether that detail is still necessary.
LangSmith's deepest integration is with LangChain and LangGraph — tracing is often enabled with a single environment variable. This ease of setup also creates switching costs. Moving to a different observability tool means manually instrumenting your calls with that tool's SDK, which can be significant effort depending on how many services and agents you run.
Trace data portability matters. LangSmith stores your trace history, evaluation datasets, and annotation results. If you leave, export this data before your retention window expires. The API supports bulk export but it requires engineering effort. Your evaluation datasets — curated inputs and expected outputs built over time — are particularly valuable and worth exporting regardless of migration plans.
If cost is the primary driver, consider Langfuse as a self-hosted alternative. It's open-source with similar tracing and evaluation capabilities. Self-hosting eliminates per-seat and per-trace fees, though you take on infrastructure and maintenance. Langfuse also offers a cloud-hosted version with its own pricing tiers for teams that don't want to manage infrastructure.
No credit card required
Create an account, install the SDK, and see your first margin data in minutes.
See My Margin DataNo credit card required