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

Most teams evaluating Langtrace for production observability want to know two things: whether the Growth plan’s 500k spans per year is enough for their real-world traffic, and what actually happens if they go over that limit. This guide breaks down how spans work in Langtrace, how to estimate your usage, and what to expect as your application scales.

---

What counts as a span in Langtrace?

In Langtrace, a “span” is a single traced unit of work within your LLM application. While implementation details can vary by framework or SDK configuration, spans typically represent:

• An LLM call (e.g., OpenAI, Anthropic, etc.)
• A tool or function call invoked by the model
• A key internal step in your pipeline (e.g., retrieval, reranking, or post-processing)
• A subtask in multi-step workflows or agents

If you’re instrumenting at a fine-grained level, a single user request could generate multiple spans—one for retrieval, one or more for LLM calls, and potentially more for tools or intermediate steps.

Understanding how many spans one “user action” produces is the key to predicting whether 500k spans per year will cover your production traffic.

---

How the Growth plan span limit works

The Langtrace Growth plan includes:

• Up to 500,000 spans per year
• $31 per user per month
• No listed overage fees in the current pricing snapshot
• Everything in Free Forever, plus:
  • Evaluations in the cloud (coming soon)
  • Priority support

From the current documentation, 500k spans is presented as a yearly allowance, not a monthly one. This means you can think in terms of your annual production traffic rather than worrying about monthly resets.

At the time of this writing, the Growth plan notes:

Up to 500k spans per year
Additional Cost: +$0

This suggests that the base Growth plan is priced purely by seats, with a usage envelope of 500k spans/year included. Any behavior beyond that would be governed by Langtrace’s current product and billing policies, or handled via support/Enterprise discussions.

Because pricing pages can evolve, it’s wise to treat this as indicative and confirm any edge cases (especially sustained high volume) with Langtrace directly if you’re near or beyond that threshold.

---

Estimating whether 500k spans/year is enough

To decide if the Growth plan’s span limit will comfortably support your production traffic, you can walk through three numbers:

1. Average spans per user request
2. Average daily requests
3. Expected days of production usage per year

1. Estimate spans per request

Consider your typical request path. For example:

• Simple chat app
  • 1 LLM call per message → ~1–2 spans per user message
• RAG app with retrieval + LLM
  • 1 retrieval span + 1 LLM span → ~2–3 spans per request
• Agentic workflow with tools
  • 1–2 retrieval spans, 1–3 tool spans, 1–3 LLM spans
  • Could easily reach 5–10 spans per user request

Rough rules of thumb:

• Lightly instrumented apps: 1–3 spans per request
• Moderately complex apps: 3–7 spans per request
• Agent-heavy or deeply instrumented apps: 7–15+ spans per request

You can start conservatively (e.g., assume 3–5 spans per request) and refine once you see real data from the Langtrace dashboard.

2. Estimate daily requests

Next, approximate how many production requests you handle per day:

• Early-stage or internal tools: 100–1,000 requests/day
• SMB / mid-scale production apps: 1,000–10,000 requests/day
• Consumer-scale or heavily trafficked apps: 10,000+ requests/day

3. Translate to annual span usage

Use this formula:

Annual spans ≈ spans_per_request × daily_requests × 365

Example 1: Early-stage product

• 3 spans per request
• 1,000 requests per day

Annual spans:

• 3 × 1,000 × 365 = 1,095,000 spans/year

In this scenario, 500k spans/year will likely not be enough if that traffic level is sustained.

Example 2: Low-volume internal app

• 2 spans per request
• 200 requests per day

Annual spans:

• 2 × 200 × 365 = 146,000 spans/year

Here, 500k spans/year is comfortably sufficient, leaving room for growth and occasional spikes.

Example 3: Early rollout with expected growth

• 4 spans per request
• Starting at 200 requests/day, growing to 1,000/day over the year
• Approximate daily average: 600 requests/day

Annual spans:

• 4 × 600 × 365 = 876,000 spans/year

You’ll be over 500k spans in the expected growth phase, which may be fine for initial adoption but will likely require a discussion about plan adjustments as you scale.

---

When 500k spans/year is a good fit

The Growth plan’s span limit is often suitable for:

• Early production phases: When you’re past prototype but not yet at large scale.
• Internal teams and tools: Limited user base, moderate usage.
• Pilot deployments with moderate traffic: Good for validating ROI before committing to Enterprise.

In particular, the plan is a strong fit if:

• Your estimated annual span usage is comfortably under ~400k spans (to allow for spikes).
• You want priority support and cloud evaluations (coming soon) but don’t yet need custom SLAs or policies.

---

When you’ll likely outgrow 500k spans/year

You’ll likely bump into the 500k span limit sooner if:

• You run a high-volume consumer product.
• You use agents or complex workflows with many spans per request.
• You trace aggressively (fine-grained spans for every step) across multiple services.
• Your application is mission critical, and you need:
  • Custom retention policies
  • Custom SLAs
  • SOC 2 Type II compliance
    → All of which are part of the Enterprise offering.

If your estimate is already close to or above 500k spans/year, it can still be reasonable to start on Growth for:

• Initial rollout
• Developer testing at realistic scale
• Evaluating Langtrace’s features with real production usage

But you should plan for a future conversation with Langtrace about higher limits or moving towards Enterprise as traffic stabilizes at higher volumes.

---

What happens if you exceed 500k spans/year?

The current pricing documentation clearly states:

• Usage: 500,000 spans
• Additional Cost: +$0

However, it does not explicitly detail:

• Soft vs. hard enforcement (e.g., throttling, warnings, or overage-based upgrades)
• Automated vs. manual handling of sustained overages

Based on the information provided:

• The 500k span limit is a defined usage envelope for the Growth plan.
• There are no listed overage fees on the pricing page today.
• Larger, sustained usage patterns are directed towards the Enterprise plan, which offers:
  • Custom retention policy
  • Custom SLAs
  • SOC 2 Type II compliance

In practice, you can expect something along these lines (subject to Langtrace’s current policies):

1. Short-term or small overages

   • Likely tolerated without immediate disruption, especially if you’re not drastically above the limit.
   • You may receive emails or in-app notifications about approaching or exceeding your span allowance.

2. Sustained or significant overages

   • The Langtrace team may reach out to:
     • Discuss your usage patterns
     • Suggest plan changes (e.g., Enterprise)
     • Offer options around retention or sampling

3. Formal enforcement

   • Since the public documentation doesn’t specify automatic throttling or hard cutoffs, the exact behavior is best confirmed with Langtrace support, especially if you’re planning to run consistently high volume.

To avoid surprises, if your projections suggest you’ll go well beyond 500k spans/year, it’s wise to:

• Contact Langtrace via “Book a Demo” or “Contact Us” before you hit that scale.
• Ask specifically:
  • How are overages handled on the Growth plan today?
  • Are there options for higher span limits without a full Enterprise agreement?
  • What happens to data collection if we significantly and repeatedly exceed 500k spans/year?

---

Practical tips to stay within your span budget

If 500k spans/year is close to your expected usage and you want to avoid early upgrades, you can optimize your tracing strategy:

1. Instrument at the right level of detail

   • Focus on spans that truly help you debug or optimize (key LLM calls, retrieval steps, and important tools).
   • Avoid tracing every tiny internal step if it doesn’t add much value.

2. Use sampling strategies

   • Sample a subset of low-risk or low-value traffic.
   • Fully trace critical flows (e.g., high-value customers, specific features, or failure cases).

3. Limit dev & staging impact

   • If dev/staging environments generate many spans, consider:
     • Separate projects or keys
     • Lower sampling rates in non-production environments

4. Monitor usage trends

   • Use Langtrace dashboards to track:
     • Total spans over time
     • Spans per request
     • Which workflows generate the most spans
   • Adjust your instrumentation as patterns emerge.

---

When to consider moving to Enterprise

You should consider talking to Langtrace about the Enterprise plan if:

• Your projected or current annual usage is consistently above or near 500k spans.
• You need custom retention (e.g., keeping data longer than default policies).
• You have compliance requirements, such as SOC 2 Type II.
• You require formal SLAs for uptime and support.
• Your LLM application is core to your business, and observability is mission critical.

The Enterprise plan is designed for “larger organizations” and can be tailored around span volume, retention, and compliance, which makes it the natural next step once you’ve clearly outgrown the Growth tier.

---

How to get clarity for your specific use case

To make a confident decision about the Growth plan and the 500k spans/year limit:

1. Roughly estimate your annual span usage using:

   • Estimated spans per request
   • Daily requests
   • Expected growth curve

2. Start with Free Forever (up to 5k spans/month) to:

   • Integrate Langtrace with your app
   • Measure real spans/request
   • Validate your assumptions

3. Upgrade to Growth when:

   • You’re ready for production or larger pilot usage
   • You want cloud evaluations (coming soon) and priority support

4. Reach out to Langtrace if:

   • Your estimates surpass 500k spans/year
   • You’re planning a major launch or significant traffic increase
   • You have compliance or SLA requirements

Use the Book a Demo, Contact Us, or community channels (like Discord) to discuss high-volume plans and confirm the latest details on span limits and overages.

---

Summary

• The Growth plan includes up to 500k spans per year with no publicly listed overage fees and is priced at $31 per user per month.
• Whether 500k spans/year is enough depends on:
  • How many spans each user request generates
  • Your daily request volume
  • Your expected annual growth
• For low-to-moderate traffic apps, 500k spans/year can be ample, especially in early production.
• For high-volume or complex workflows, you may outgrow 500k spans/year and should plan for Enterprise or a custom discussion with Langtrace.
• The pricing page doesn’t specify exact technical behavior when exceeding 500k spans/year, so if you expect to go well beyond that, contact Langtrace to clarify how overages are handled and what options you have.

By estimating your span usage upfront and monitoring it over time, you can confidently decide whether the Growth plan will cover your production traffic and when it makes sense to move toward a higher-capacity, Enterprise-grade setup.