I’m hitting the 25k spans/month limit on Arize AX Free—how do I upgrade to Pro and what changes (retention, ingestion, support)?

If you’re regularly hitting the 25k spans/month limit on Arize AX Free, that’s a strong signal your tracing is doing its job—and that you’ve outgrown the starter tier. Moving to AX Pro gives you more headroom for spans and ingestion, longer retention for investigations, and direct email support without changing your existing instrumentation or agents.

Quick Answer: To upgrade from Arize AX Free to AX Pro, go to your AX account’s billing or plan settings and select the AX Pro plan (currently $50/month for small teams and startups). AX Pro increases your span limit to 50k spans/month, bumps ingestion to 10 GB/month, extends retention to 30 days, and adds higher rate limits plus email support—everything else in your tracing and eval setup continues to work as-is.

Why This Matters

When you’re running agents in production, hitting the 25k spans/month limit usually happens right when you need more—not less—visibility: new tools, more concurrent users, or added evals can quickly consume span budget. If you stay on AX Free and keep hitting the cap, you risk blind spots:

• Traces getting dropped when you need to debug regressions
• Short retention forcing you to investigate issues with incomplete context
• Limited ingestion constraining richer spans (e.g., more context, multi-modal data)

Upgrading to AX Pro keeps the same open standards (OpenTelemetry, OpenInference) and workflow you’ve built, but with more capacity and support so you can trace “the full flow” reliably as you scale.

Key Benefits:

• Higher capacity without re-instrumenting: Jump from 25k to 50k spans/month and from 1 GB to 10 GB ingestion without changing your OTEL setup or SDKs.
• Longer lookback for debugging: Move from 15 days to 30 days of retention so you can investigate slow-burn issues and compare behavior across deployments.
• Better support as you scale: Gain higher rate limits and email support so you’re not alone when you hit edge cases or need guidance on tracing, evals, or monitors.

Core Concepts & Key Points

Concept	Definition	Why it's important
Trace spans/month limit	The maximum number of spans Arize AX will store for your account each month. AX Free includes 25k spans/month; AX Pro increases this to 50k spans/month.	Spans are the backbone of your agent observability. If you regularly hit the limit, parts of your agents’ behavior can go unseen—especially during peak traffic or new releases.
Retention window	How long Arize stores your spans and associated data before they age out. AX Free keeps data for 15 days; AX Pro extends that to 30 days.	Longer retention lets you investigate issues that emerge slowly, compare behavior before vs. after a change, and mine past incidents for new eval datasets.
Ingestion volume	The total volume of data (spans, metadata, payloads) you can send per month. AX Free provides 1 GB/month; AX Pro increases this to 10 GB/month.	As you add more detailed spans, multi-agent graphs, and eval outputs, ingestion volume can become a bottleneck. More volume means you don’t have to under-instrument to stay under the cap.

How It Works (Step-by-Step)

The upgrade from AX Free to Pro is designed to be a configuration change, not an engineering project. Your spans, traces, and evals stay aligned with OTEL and your current conventions; you just unlock more capacity and support.

1. Confirm you’re actually hitting the 25k spans/month limit

   • Check your usage in the AX UI (billing or usage section) to see monthly spans and ingestion.
   • Look for symptoms: missing traces during peaks, warnings about rate limits, or inability to see recent days when you expect them.
   • If you’re close to the limit every month—especially in active development—it’s time to move.

2. Upgrade your plan inside Arize AX

   • From your AX account, navigate to Settings → Billing / Plan.
   • Select AX Pro (Small teams and startups); the current price point is $50 per month.
   • Confirm your billing details and apply the upgrade. The plan change should apply to future usage within the same account/organization context.

3. Operate with the new limits (and plan your next phase)

   • After upgrading, your new limits are:
     • Trace spans: 50k spans/month
     • Ingestion volume: 10 GB/month
     • Retention: 30 days
   • You also get:
     • Higher rate limits
     • Email support
   • With more span budget and retention, you can:
     • Log more granular spans (e.g., tool sub-calls, intermediate reasoning steps)
     • Turn on more online evals and custom metrics
     • Store traces long enough to feed CI/CD experiments and annotation queues

What Actually Changes When You Go From AX Free to AX Pro

Here’s the side-by-side, focusing on the parts that matter for agent reliability.

Plan mechanics

• Price & target teams
  • AX Free: $0/month, designed for individuals and very early-stage startups.
  • AX Pro: $50/month, designed for small teams and startups that are going beyond demos into real users and SLOs.

Usage limits

• Trace spans

  • AX Free: 25k spans/month
  • AX Pro: 50k spans/month
  • Impact: You can trace roughly double the number of requests at the same granularity—or keep the same volume and increase span detail (e.g., instrument every tool call plus retry path instead of only top-level prompts).

• Ingestion volume

  • AX Free: 1 GB per month
  • AX Pro: 10 GB per month
  • Impact: Gives breathing room to:
    • Store richer metadata on spans (inputs, retrieved documents, tool outputs).
    • Trace multi-modal interactions.
    • Capture eval outputs, custom metrics, and more context without trimming payloads aggressively.

• Retention

  • AX Free: 15 days
  • AX Pro: 30 days
  • Impact:
    • You can investigate incidents that surface late (e.g., after a gradual rollout).
    • You can compare “before/after” behavior when you change prompts, models, or routing.
    • You get a bigger window to convert production traces into datasets for experiments, evals, and annotation queues.

Support & reliability

• Rate limits

  • AX Free: Baseline limits suitable for low-throughput experimentation.
  • AX Pro: Higher rate limits, so you’re less likely to hit throttling as you scale concurrent traffic and evaluation workloads.

• Support

  • AX Free: Community support.
  • AX Pro: Email support, so you can get help when:
    • You’re instrumenting a new framework or language.
    • You’re wiring OTEL traces across multiple services.
    • You’re setting up monitors or online evals and want best practices.

Everything you get in AX Free is included in AX Pro, plus these higher operational limits and support. You still get access to Arize AX capabilities like:

• OTEL-based spans and traces, session support, and multi-agent graphs
• Token and cost tracking
• Custom metrics and custom dashboards
• Online evals to catch issues in real time
• Access to Alyx, the Arize agent that helps you build and debug agents

Your existing instrumented spans keep flowing—just with more headroom and longer history.

Common Mistakes to Avoid

• Mistake 1: Upgrading plans without fixing noisy or redundant spans

  • If you’re hitting 25k spans purely due to “span spam” (duplicated spans, overly verbose logs on non-critical paths), upgrading alone won’t solve the root problem.
  • How to avoid it:
    • Audit your current tracing: Are you logging every retry attempt, every token, or repeated metadata that doesn’t help you debug?
    • Consolidate low-value spans into higher-level spans that preserve observability without blowing up counts.
    • Keep critical spans: agent planning/decision steps, tool calls, retrieval calls, and external API boundaries.

• Mistake 2: Treating higher limits as an excuse to skip monitors and evals

  • More spans and retention should support better evaluation and monitoring—not replace them. If you just collect more data without evals, you’re still flying blind.
  • How to avoid it:
    • Use the extra capacity to:
      • Add online evals on key agent paths (e.g., hallucination checks, tool selection quality).
      • Define custom metrics (success rate, tool-call error rate, cost per session).
      • Set up dashboards and alerts tied to your SLOs.

Real-World Example

At my marketplace, we started on a free-tier setup for early agent prototypes and hit span caps almost immediately once we rolled out to real traffic. We had:

• OTEL tracing on every agent step (planner, tool calls, router decisions).
• LLM-as-a-Judge evals on tool selection and parameter extraction.
• CI/CD experiments that loaded up traces around deployments.

We were bumping into span and ingestion limits at the worst moments—during peak traffic and after major prompt changes. Upgrading to a Pro-level tier with more spans, 30-day retention, and better rate limits let us:

• Keep fine-grained spans (including retries and backoff decisions) instead of trimming them.
• Investigate issues that only appeared after a week of gradual rollout.
• Build a rolling 30-day dataset of real traces that fed into our experiments and annotation queues.

The technical stack didn’t change: same OTEL collectors, same OpenInference conventions. We just gained enough capacity to keep our “full flow” tracing intact and connect production behavior directly into evaluation-driven iteration.

Pro Tip: Before and after upgrading, tag your spans with environment and version (e.g., env=prod, release=v1.23) so that once you have 30-day retention, you can compare specific deployments in Arize dashboards and experiments instead of eyeballing time ranges.

Summary

If you’re hitting the 25k spans/month limit on Arize AX Free, AX Pro is the natural next step for any team moving beyond demos into real production traffic. The upgrade keeps your open-standard tracing intact and simply raises the ceiling:

• Span limit goes from 25k → 50k spans/month.
• Ingestion volume goes from 1 GB → 10 GB/month.
• Retention goes from 15 days → 30 days.
• You also gain higher rate limits and email support.

That extra capacity is what lets you trace the full multi-agent flow, run online evals, maintain dashboards, and still have enough history to debug regressions and feed CI/CD experiments—without re-instrumenting or accepting blind spots.

Next Step

Get Started