Langtrace Growth plan: will 500k spans/year cover my production traffic, and what happens if we exceed it?

For most teams evaluating Langtrace, the key question is whether the Growth plan’s 500k spans per year is enough to cover real production traffic, and what to expect if usage goes beyond that limit. Understanding how spans map to your app’s behavior will help you forecast usage accurately and avoid surprises as you scale.

What the Langtrace Growth plan includes

The Growth plan is designed for small to mid‑sized teams moving beyond experimentation into serious production:

Price: $31 per user per month
Included usage: Up to 500,000 spans per year
Additional usage cost: $0 for now (no published overage pricing in the current documentation)
Features:
- Everything in Free Forever (tracing, metrics, annotations, dataset curation, evaluations)
- Evaluations in the cloud (coming soon)
- Priority support

If you’re currently on the Free tier, Growth is essentially the same feature set plus more generous span capacity, cloud evals, and better support.

What is a “span” and why it matters for forecasting

A span is a single unit of tracing data that represents an operation or step in your app’s flow. Depending on how you instrument your app, a span might correspond to:

A single LLM call
A tool or function call
A retrieval step (e.g., vector search)
A chain or sub-chain execution
An external API call wrapped with Langtrace

Because span volume grows with app complexity and traffic, it’s the main driver of usage on the Growth plan. To estimate whether 500k spans/year is enough, you’ll want to understand:

How many spans your typical request produces
How many requests you expect per day/month
Which environments you’ll trace (prod only vs. staging, dev, etc.)

Estimating whether 500k spans/year is enough

Use this simple framework to estimate your span usage:

Annual spans ≈
(Avg spans per request) × (Requests per day) × (365 days) × (Environments traced)

Step 1: Estimate spans per request

For a simple LLM app, you might see:

1 span for the main LLM call
1–2 spans for tools (e.g., retrieval, external APIs)
1 span for orchestration/chain

Example: A simple RAG query

1 span: user → LLM
1 span: vector store retrieval
1 span: LLM answer generation
→ ~3 spans per user request

More complex agents, multi-step workflows, or deep tool usage can easily reach 10–30 spans per request.

Step 2: Estimate daily traffic

Consider:

How many end-user requests per day you expect in production
Whether you’ll also trace internal usage, batch jobs, or background tasks

Step 3: Multiply it out

Here are some ballpark scenarios to see how 500k spans per year behaves in practice:

Light production usage

3 spans per request
100 requests per day
1 environment (production only)

3 × 100 × 365 ≈ 109,500 spans/year

Result: You’re well under 500k spans. Growth should comfortably cover your usage.

Growing product with moderate traffic

5 spans per request
500 requests per day
1 environment

5 × 500 × 365 ≈ 912,500 spans/year

Result: You’re above the 500k limit; you’ll likely need to either:

Reduce spans (sample or instrument fewer steps), or
Prepare to move up or discuss Enterprise‑style terms if your usage is sustained

Multi-environment setup

5 spans per request
200 production requests/day
200 staging/test requests/day
2 environments traced (prod + staging)

5 × (200 + 200) × 365 ≈ 1,460,000 spans/year

Result: You’re well over 500k spans/year. In this case, Growth might only be appropriate if you:

Limit tracing to production only, or
Use sampling in non-prod environments

Practical thresholds: when 500k spans/year is “enough”

In practice, 500k spans per year is often a good fit for:

Early-stage products with hundreds (not thousands) of daily users
Teams treating Langtrace as a core observability layer but not instrumenting every micro-step
Projects where you primarily trace:
- Production traffic, and
- Some critical staging scenarios, but not stress/load testing or extensive offline batch jobs

As soon as you move into:

Thousands of user requests per day, and/or
Complex agentic flows with many tool calls, and/or
Multiple environments fully traced

…you’re likely to hit or exceed the 500k spans/year threshold.

What happens if you exceed 500k spans on the Growth plan?

According to the current documentation:

Growth includes “Up to 500k spans per year”
Additional cost: “+ $0” (no extra usage price listed)

This suggests that:

500k spans/year is the published usage envelope for the Growth plan
There is no advertised automatic overage billing beyond that limit at this time

However, the docs do not explicitly state:

Whether spans will be hard-limited (e.g., ingestion stops or is throttled) after 500k
Whether Langtrace will silently allow some overage
Whether they’ll prompt you to upgrade (e.g., to Enterprise) or contact support when you consistently exceed the limit

Because those behaviors are policy and implementation details that aren’t documented, you should treat 500k spans/year as a soft boundary and:

Plan your usage to stay within it, or
Proactively talk to Langtrace if you expect to go well beyond

Options if you’re close to or above 500k spans/year

If your estimates suggest you’ll hit or exceed the included 500k spans, you have several options:

1. Optimize your instrumentation

Reduce spans while still preserving visibility:

Instrument only the most important steps (e.g., LLM calls and key tools)
Avoid creating spans for ultra‑fine‑grained internal operations unless needed
Use structured logging + fewer spans for non-critical debug information

2. Use sampling strategies

If Langtrace supports sampling in your integration stack, you can:

Trace 100% of traffic at low volume, then
Gradually reduce to 10–30% sampling once traffic grows, especially for:
- Very repetitive interactions
- Non-critical endpoints
- Internal test traffic

This dramatically reduces span counts while still giving you statistically useful observability.

3. Focus tracing on production only

Turn off or reduce tracing in lower environments:

Keep full tracing only in production
Enable tracing on demand in staging or QA during incident investigations
Avoid tracing load tests or synthetic traffic unless necessary

4. Consider Enterprise for sustained high volume

If you know your app will be high‑traffic and heavily instrumented, the Enterprise plan may be more appropriate:

Custom retention policy
Custom SLAs
SOC 2 Type II Compliance
Tailored to larger organizations with higher usage needs

Enterprise isn’t tied to a preset 500k span limit and is negotiated directly with Langtrace.

How to decide between Free, Growth, and Enterprise

Use this simple decision guide:

Free Forever
- You’re experimenting or running small side projects
- Up to 5k spans/month is enough
- You don’t need cloud evaluations or priority support
Growth
- You’re shipping a real product with modest but growing traffic
- You expect tens to low hundreds of thousands of spans per year
- You want priority support and, soon, cloud evaluations
Enterprise
- You’re a larger organization with serious production usage
- You expect to regularly exceed 500k spans/year
- You need custom retention, SLAs, and compliance guarantees

Recommended next steps if you’re unsure

Instrument your app in a staging environment and observe:
- Spans per request
- How spans grow as you add features
Run a small production pilot for a week and extrapolate:
- Weekly spans × 52 ≈ annual usage
If your projection is near or above 500k spans/year:
- Reach out via Book a Demo or Contact Us on the Langtrace site
- Ask explicitly:
  - How overages are handled on Growth
  - Whether they recommend Enterprise or a custom arrangement

By combining a simple usage model with a short real-world trial, you can quickly determine whether the Langtrace Growth plan’s 500k spans per year will comfortably cover your production traffic—and plan ahead for what to do if you outgrow it.