Arize pricing: what are the current limits for AX Free and AX Pro (spans/month, ingestion, retention)?

Arize AX plans are designed around real production workloads, so span volume, ingestion limits, and retention are the key levers—not feature lock-in. If you’re choosing between AX Free and AX Pro, you’re really deciding how much trace data you need to reliably debug and monitor agents, and how long you need to keep it in the system.

Quick Answer: AX Free includes 25k trace spans per month, 1 GB of ingestion, and 15 days of retention. AX Pro increases this to 50k spans per month, 10 GB of ingestion, and 30 days of retention, with higher rate limits and email support on top of the core platform.

Why This Matters

For agent and LLM teams, spans and retention aren’t abstract pricing metrics—they directly control how much of your production behavior you can see and how far back you can go when debugging regressions. If you outgrow your plan, you’ll either drop data or fly blind on older traces, which makes it harder to prove or disprove whether a prompt change, routing tweak, or model swap actually improved quality.

Key Benefits:

• Right-size observability: Match span/month and ingestion limits to your actual traffic so you can trace “the full flow” for each request instead of sampling away critical context.
• Keep a useful debugging history: Longer retention lets you correlate incidents, regressions, and SLO violations over weeks instead of days.
• Scale up without re-architecting: Moving from AX Free to AX Pro (and later to AX Enterprise) keeps the same tracing, eval, and monitoring model—no refactors, just higher limits and more controls.

Core Concepts & Key Points

Concept	Definition	Why it's important
Trace spans per month	The total number of spans (units of work in a trace) you can send to Arize AX in a month.	Each tool call, model invocation, or agent step is a span. Higher limits mean you can capture full multi-step agent flows without aggressive sampling.
Ingestion volume (GB/month)	The total data volume (payloads, metadata, span attributes) you can ingest into AX each month.	Richer context per span (inputs, outputs, embeddings, metadata) consumes more bytes. You want enough room to log what you need for debugging, not just minimal skeleton traces.
Retention (days)	How long Arize AX keeps your traces and spans available for search, analysis, evals, and dashboards.	Retention defines your “time window” for debugging incidents, comparing behavior before/after releases, and mining edge cases into eval datasets.

How It Works (Step-by-Step)

One platform. You pick a plan; the tracing and evaluation model stays the same. The limits just define how much data you can push through it and how long it stays available.

Plan basics today:

• Arize AX Free (Individuals and startups)

  • 25k trace spans per month
  • 1 GB ingestion per month
  • 15 days retention
  • Core additions beyond Phoenix: Alyx (Arize agent), Online Evals, product observability (monitors & custom metrics), community support

• Arize AX Pro (Small teams and startups)

  • 50k trace spans per month
  • 10 GB ingestion per month
  • 30 days retention
  • Everything in AX Free, plus higher rate limits, longer retention, and email support

• AX Enterprise (for completeness)

  • Custom spans, ingestion, projects, and retention
  • Additional enterprise controls (dedicated support, SLAs, compliance, adb Data Fabric, self-hosting add-ons for data residency and multi-region)

From there, the workflow is straightforward:

1. Instrument your agents and tools with OTEL/OpenInference

   • Use Arize SDKs (Python, JavaScript) or OpenTelemetry to emit spans for each model call, tool call, and agent step.
   • Make sure every request logs “the full flow” as a trace: entry span → router → tools → LLM calls → outputs.
   • Keep an eye on span cardinality to stay within your plan limits (e.g., avoid unbounded span creation for loops).

2. Stream traces into AX within your plan limits

   • AX Free: ideal for early prototypes, side projects, or low-traffic agents.
   • AX Pro: better for small teams running real workloads with stricter debugging needs.
   • If you’re consistently hitting 70–80% of your spans or GB per month, you’re likely ready to move up a tier or discuss Enterprise.

3. Use retention to close the loop between incidents and improvements

   • Within your retention window, you can:
     • Replay and debug traces in the UI.
     • Run offline evaluations and experiments on stored data.
     • Build annotation queues from real-world edge cases.
   • Once traces age out of retention, they’re no longer available for search and evals, so use datasets/exports for anything you’ll need beyond that window.

Common Mistakes to Avoid

• Underestimating spans per request:
  It’s easy to budget “one span per request” and forget that a realistic agent flow might generate 10–50 spans (router, tools, retries, nested calls). Model your average spans-per-request early and choose a plan accordingly.

• Ignoring retention when planning incident response:
  If your incident review cycles and compliance requirements assume 30 days of trace history, 15-day retention on AX Free might be too short. Move to AX Pro or Enterprise before you rely on that history for audits or RCA.

Real-World Example

Imagine a small marketplace team rolling out an order-support agent. In the first month, they instrument everything with OpenTelemetry and start on AX Free. The agent gets light traffic—just a few hundred sessions per day—and 25k spans / 1 GB ingestion is more than enough. They use Online Evals to gate prompt changes and Alyx to help instrument a couple of new tools.

Two months later, traffic spikes: the agent is now handling a few thousand sessions per day, and each complex path produces ~20 spans (router → multiple tools → additional LLM calls). Suddenly, they’re approaching the 25k-span limit in a week, and 15-day retention isn’t enough to investigate regressions over a full release cycle.

They switch to AX Pro for 50k spans and 10 GB ingestion, plus 30-day retention. Now they:

• Capture full multi-agent graphs for every request instead of sampling.
• Use 30-day history to compare behavior before/after a major prompt refactor.
• Build annotation queues from last month’s tricky disputes to create a golden dataset.

Pro Tip: Before selecting a plan, calculate spans like an SRE would size a service: estimate average spans per request × peak RPS × 30 days. If your estimate is within 2–3x of the plan’s span/month limit, move up a tier or talk to Arize about custom Enterprise limits so you don’t end up silently dropping critical trace detail.

Summary

AX Free and AX Pro share the same core: OpenTelemetry-based tracing, evaluation-driven iteration, and observability for agents. The difference is how much you can send (spans/GB) and how far back you can see (retention). AX Free gives individuals and early-stage teams 25k spans, 1 GB, and 15 days to get started; AX Pro doubles spans, multiplies ingestion by 10x, and extends retention to 30 days with higher rate limits and email support—enough for many small, production-grade workloads. When your agents become business-critical or regulated, AX Enterprise gives you custom limits, adb Data Fabric, and self-hosting options to match.

Next Step

Get Started