LangChain LangSmith pricing: how do Developer vs Plus vs Enterprise work (seats + usage), and what’s included?

Most teams evaluate LangSmith on two axes: how many people need seats, and how many traces their agents will generate in development and production. The Developer, Plus, and Enterprise plans are all built around that same structure—seats plus usage—so you can start small and scale without changing tools.

Quick Answer: LangSmith pricing combines seat-based access with pay-as-you-go trace volume. The Developer plan fits individual builders, Plus is for self-serve teams with collaboration and deployment needs, and Enterprise adds advanced security, support, and deployment options.

The Quick Overview

• What It Is: A trace-first agent engineering platform to build, observe, evaluate, and deploy AI agents, priced by seats plus usage.
• Who It Is For: Developers and teams running anything from hobby agents to Fortune 500–scale, production workloads.
• Core Problem Solved: You get full visibility into agent behavior—without overpaying for capacity you don’t use—and can scale from prototype to production under one pricing model.

How LangSmith pricing works at a high level

LangSmith has three main commercial tiers:

• Developer: One free seat, a base trace allowance, and pay-as-you-go usage on top. Ideal for personal projects and early-stage validation.
• Plus: Unlimited self-serve seats, higher included usage, and managed LangSmith Deployment so you can run real production agents with collaboration.
• Enterprise: Contract-based pricing for organizations that need advanced admin, security, support, and custom deployment (including hybrid or self-hosted).

Across all paid tiers:

• Seats are billed monthly for Developer and Plus plans (self-serve, on the 1st, pro-rated when you add seats).
• Traces are billed monthly in arrears based on what your agents actually did in that period.
• Enterprise is invoiced annually upfront, with custom terms.

1. How seats work

Seats control who can log in to LangSmith, view traces, configure evals, and manage deployments:

• Developer plan
  • Includes 1 free seat.
  • Designed for an individual engineer or founder.
• Plus plan
  • Lets you buy unlimited seats via self-serve.
  • Built for teams that need shared projects, dashboards, and annotation queues.
• Enterprise
  • Seat counts and pricing are negotiated.
  • Layered with enterprise identity controls (SSO/SAML, SCIM) and granular RBAC/ABAC.

Seats are billed:

1. Monthly on the 1st for Developer and Plus.
2. Pro-rated when added mid-month (you pay for the remaining portion of the month).
3. No credit for removed seats mid-month—removal takes effect for the next billing period.

2. How usage (traces) works

Traces are the core usage metric. A trace captures the end-to-end run of your agent or LLM call, including:

• Tool calls
• Intermediate steps
• Multi-turn threads
• Errors, retries, loops

Why traces? They’re the only reliable record of what your agent actually did at runtime. Pricing against trace volume aligns directly with how much you’re running and debugging agents, not how many projects you have.

Key points:

• All plans include a base number of traces per month, then bill extra trace volume on top.
• Usage is billed monthly in arrears—you pay after you’ve used it, based on real traffic.
• Paid plans scale with trace volume, so as you push more traffic into production, your bill scales in a predictable way.

From the official docs:

• Developer: 1 free seat with 5k base traces/month included.
• Plus: Unlimited seats with 10k base traces/month included.
• Enterprise: Custom—larger allocations, longer retention, and pricing negotiated with sales.

You can also:

• Integrate tracing with any agent stack via SDKs (Python, TypeScript, Go, Java) or OpenTelemetry.
• Route all prod traffic to LangSmith or start with sampled traces and increase coverage as you harden your agents.

3. How billing works per plan

1. Developer & Plus (self-serve)
   • Seats: Billed monthly, upfront.
   • Traces: Billed monthly in arrears.
   • Payment: Card-based, via dashboard.
2. Enterprise
   • Contract: Annual invoice upfront.
   • Usage: Custom thresholds and overage rates defined in your order form.
   • Procurement: Standard infosec review and legal terms built in.

Plan-by-plan breakdown

Developer plan: best for individual builders

The Developer plan exists to let you get hands-on with real agents without friction.

What you get:

• 1 free seat
• 5k base traces/month included
• Access to the full LangSmith trace UI:
  • Run timelines, threads, tool call inspection
  • Sampling, filtering, and search
• Ability to:
  • Turn production runs into datasets
  • Run offline evaluations (including LLM-as-judge)
  • Integrate from any framework using SDKs or OpenTelemetry

When it’s a fit:

• You’re validating agent patterns solo (retrieval, tool use, multi-agent).
• You want trace-first observability but don’t yet have a full team.
• Your workloads are dev-heavy and low volume in production.

Once you need other people in the loop—peer review, annotation queues, shared deployments—you’ve outgrown Developer and should move to Plus.

Plus plan: best for self-serve teams

The Plus plan is built for teams that want to collaborate and ship production agents without waiting on a sales cycle.

What you get (in addition to Developer):

• Unlimited self-serve seats (add as many team members as you need)
• 10k base traces/month included
• Full access to:
  • LangSmith Deployment: managed runtime for agents
    • 1 free dev-sized deployment included to start shipping
    • Durable checkpointing and exactly-once execution
  • Team collaboration features:
    • Shared projects and dashboards
    • Annotation queues for SMEs
    • Multi-turn and LLM-as-judge eval workflows (including Align Evals)
  • Integration with:
    • LangChain, LangGraph, Deep Agents
    • Any agent stack via SDKs and OpenTelemetry

When it’s a fit:

• You have a small to mid-sized team actively developing agents.
• You need shared visibility: everyone can inspect the same traces and compare runs.
• You want to ship agents into production using LangSmith’s managed runtime.
• You want structured evaluation (LLM-as-judge + human feedback) to catch regressions before deploy.

Plus is “good for LLM apps, serious about agents”—you can go from dev traces to production agents without swapping tools.

Enterprise plan: best for large, regulated, or complex orgs

Enterprise is for when LangSmith becomes part of your production infrastructure and governance stack.

What you get (in addition to Plus):

• Custom pricing and volume:
  • Higher or negotiated base trace allocations
  • Annual invoicing and custom overage terms
• Advanced security & admin:
  • SSO/SAML, SCIM for automatic user provisioning
  • Fine-grained RBAC/ABAC for project- and tool-level access control
  • Audit logs for compliance
  • US/EU data residency, hybrid and self-hosted deployment options
• Operational scale:
  • Support for ingesting 1B+ events per day
  • Reliability features to support Fortune 500–scale workloads
• Support & success:
  • Dedicated support team
  • Clear SLAs
  • Help with evaluation design, Align Evals calibration, and production rollout

When it’s a fit:

• You’re in a regulated industry or large enterprise.
• You need guarantees around data residency, security reviews, and vendor management.
• You want hybrid or self-hosted LangSmith where trace data never leaves your environment.

What’s included across all plans

Some fundamentals are consistent whether you’re on Developer, Plus, or Enterprise:

• Trace-first observability

  • Run timelines that show every step, in order, with inputs and outputs.
  • Threaded views for multi-turn conversations.
  • Analytics to uncover patterns and regressions across traces.

• Framework-agnostic instrumentation

  • Native integrations with LangChain, LangGraph, Deep Agents.
  • SDKs for Python, TypeScript, Go, and Java.
  • OpenTelemetry support to plug into existing observability pipelines.

• Evaluation workflows

  • Offline and online evals.
  • LLM-as-judge scoring with Align Evals to calibrate against human feedback.
  • Multi-turn evals that mirror real user behavior.
  • Dataset creation directly from production traces.

• Deployment support

  • LangSmith Deployment (dev-sized included for Plus) to host long-running, stateful agents with:
    • Durable checkpointing
    • Exactly-once execution
    • Versioning and rollbacks
    • Native support for A2A and MCP protocols
  • Fleet/Agent Builder for non-technical teams to safely create agents with admin controls and approvals.

• Data posture

  • LangSmith does not use your data to train models.
  • You own your data; see LangSmith Terms of Service for details.

Features & benefits by pricing tier

Core Feature	Developer Plan	Plus Plan	Enterprise Plan
Seats	1 free seat	Unlimited self-serve seats	Custom seat counts with SSO/SAML & SCIM
Base traces/month	5k included	10k included	Custom allocations and overage terms
Tracing & run timelines	Yes	Yes	Yes
Eval workflows (offline/online)	Yes	Yes (team-oriented workflows)	Yes (scaled with governance)
LangSmith Deployment	Limited (no included dev deployment)	1 free dev-sized deployment included	Multiple deployments, advanced controls
Collaboration (projects, queues)	Basic (single user)	Team collaboration, shared dashboards, annotation queues	Enterprise-wide collaboration with RBAC/ABAC
Security & admin controls	Standard	Team-level controls	SSO/SAML, SCIM, audit logs, granular RBAC/ABAC
Data residency & deployment options	Shared cloud	Shared cloud	US/EU residency, hybrid, and self-hosted/VPC options
Billing	Monthly self-serve (seats + usage)	Monthly self-serve (seats + usage)	Annual invoice with custom terms
Support	Community + standard support	Product support	Priority support, SLAs, dedicated contact

Ideal use cases

• Best for solo builders and early-stage validation (Developer): Because you can instrument your agents with full tracing and evals, stay within a free base usage, and only pay as your trace volume grows.
• Best for product teams shipping production agents (Plus): Because you get unlimited seats, collaboration, and managed LangSmith Deployment with a free dev environment to move from dev to prod without changing platforms.
• Best for enterprises standardizing on agents (Enterprise): Because you can enforce security, residency, approvals, and governance at scale while supporting thousands of users and billions of events.

Limitations & considerations

• Free tier scope: The Developer free seat and base traces are optimized for development and small production workloads. Heavier usage will incur trace overages or push you toward Plus.
• Support level: Some advanced support and enterprise features (custom SLAs, self-hosted, advanced identity controls) are only available on Enterprise, even though the core tracing and eval experience is largely consistent across tiers.
• Plan details can evolve: Exact quotas, overage rates, and feature packaging can change. Always confirm current details on the official pricing page.

Pricing & plans at a glance

LangSmith uses a simple pattern:

• Seats: How many people are building, observing, or evaluating agents.
• Traces: How much your agents are running in development and production.

Plans today:

• Developer:

  • 1 free seat
  • 5k base traces/month
  • Monthly self-serve billing for any additional usage
  • Best for individuals or very small projects.

• Plus:

  • Unlimited seats (self-serve)
  • 10k base traces/month
  • 1 free dev-sized LangSmith Deployment
  • Monthly self-serve billing
  • Best for teams needing collaboration and a managed runtime.

• Enterprise:

  • Custom seats and trace volume
  • Advanced admin, security, and deployment options
  • Annual invoice and custom contract
  • Best for organizations standardizing on agents at scale.

For exact per-trace and per-seat pricing, check the live pricing page or reach out to sales.

Frequently Asked Questions

Does LangSmith only work with LangChain?

Short Answer: No. LangSmith is framework-agnostic.

Details: You can use LangSmith with LangChain, LangGraph, Deep Agents, or any other agent stack. There are official SDKs for Python, TypeScript, Go, and Java, plus OpenTelemetry support to pipe traces in from custom runtimes. The pricing model (seats + traces) is the same regardless of which framework or model you use.

Will LangSmith train on my data?

Short Answer: No. LangSmith does not use your data to train models.

Details: LangSmith’s data posture is explicit: you own your data, and it is not used to train models. For self-hosted or hybrid Enterprise deployments, you can keep all trace data inside your own environment. For cloud deployments, data handling is governed by the LangSmith Terms of Service and any enterprise agreements, but in all cases, user data is not used for model training.

How do I know which plan is right for me?

Short Answer: Match seat count, trace volume, and governance needs.

Details:

• Start with Developer if you’re solo or just instrumenting your first agent.
• Move to Plus when you have multiple engineers, product managers, or SMEs needing access, or when you’re ready to deploy production agents via LangSmith Deployment.
• Talk to sales about Enterprise when you need SSO/SAML, SCIM, custom data residency, self-hosting, or you’re expecting very high trace volumes and want predictable enterprise pricing.

How am I billed for traces?

Short Answer: Traces are billed monthly in arrears based on actual usage.

Details: Each month, LangSmith counts the traces your agents generated. Your plan includes a base allocation (5k on Developer, 10k on Plus, custom on Enterprise). Any usage above that is billed at the applicable overage rate. For Developer and Plus, this charge is added to your monthly card bill; for Enterprise, overage handling is defined in your contract.

Summary

LangSmith pricing is built for how real agent teams work: seats for collaborators, traces for runtime behavior. Developer gives individuals a generous on-ramp with 5k traces/month; Plus layers in unlimited seats, higher usage, and managed deployment; Enterprise adds the controls, residency, and support that Fortune 500 teams need when agents become production infrastructure.

You don’t have to switch tools as you mature. You can start by tracing a single experimental agent and grow into a fully governed, multi-team deployment under the same trace-first platform.

Next Step

Get Started