> ## Documentation Index
> Fetch the complete documentation index at: https://arize-ax.mintlify.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Explore Your Traces
> Search, filter, and organize your traces, sessions, and spans
Your app is instrumented and traces are flowing in. Every request your app handles is now captured, but you might have thousands of them. This page walks you through how to find the ones that matter, understand what happened inside them, and organize your workflow.
Open your project and you'll see several tabs, each giving you a different lens on your data:
## Traces
This is where most investigations start. The **Traces** tab shows every request your app has handled. Click any trace to expand its span tree and see exactly what happened: which components were called, what inputs and outputs flowed through, how long each step took, and where things went wrong.
## Sessions
Your users don't send one-off requests -- they have conversations. The **Sessions** tab groups traces into conversation threads by `session.id`, so you can follow an entire interaction from start to finish and spot where things go off track.
* Sort and filter sessions by duration, total traces, user ID, or token count
* Click into a session to see the full conversation with inputs and outputs for each turn
* Export session data to CSV or via the Python SDK
* Run session-level evals to detect patterns like user frustration or unresolved issues
`session.id` must be a non-empty string. Spans with an empty session ID won't appear in the Sessions tab.
## Spans
Sometimes you need to look across all traces at a specific type of operation -- all LLM calls, all tool invocations, or all retrievals. The **Spans** tab lets you do that, showing individual units of work across your entire project.
## Token counts
Token usage directly impacts cost. Arize AX automatically computes token counts for LLM spans using the `llm.token_count.prompt`, `llm.token_count.completion`, and model name attributes, and aggregates them up to the trace level.
In the span tree, each span shows its total token count. Hover over the number to see a breakdown of prompt tokens and completion tokens, along with how they were computed (user-provided, tiktoken, or character estimate).
From here you can sort traces or sessions by token count to find expensive requests, or define [custom metrics](/ax/observe/projects/custom-metrics-api) and [monitors](/ax/observe/production-monitoring) on token usage for cost control.
***
## Explore with Skills or Alyx
Three steps to explore traces with your AI coding agent:
**Install skill**
```bash theme={null}
npx skills add Arize-ai/arize-skills --skill "arize-trace" --yes
```
**Set up authentication**
```bash theme={null}
export ARIZE_API_KEY="YOUR_API_KEY"
export ARIZE_SPACE_ID="YOUR_SPACE_ID"
```
**Ask your agent**
```
# Ask your AI coding agent:
"Export the last day of traces with errors from my project
and tell me what's going wrong"
```
Works with Cursor, Claude Code, Codex, and more. The skill runs `ax traces export` under the hood, reads the output, and summarizes patterns for you.
Open **Alyx** from the Traces page or a trace detail view and ask:
* "What are the most common error types in the last 24 hours?"
* "Filter for LLM spans with latency over 2 seconds"
* "Why did this trace fail?"
* "Create a dataset from the filtered spans"
You can also type natural language directly in the filter bar — Alyx converts it to query syntax automatically.
***
## Querying and filters
Once you know what you're looking for, use filters to narrow down. Click the filter bar to start querying -- you can type, select from suggestions, or use [AI Search](/ax/alyx/using/search-bar-agent) to generate filters from natural language.
* Format: `"dimension name" = 'value'`
* Operators: `=`, `!=`, `<`, `>`, `IN`, `contains`
* Null checks: `"attributes.input.value" = null` or `is null`
* Combine with `AND` / `OR`
* Example: `"attributes.openinference.span.kind" = 'LLM' AND "status_code" = 'ERROR'`
### Multi-span filters
Need to find traces based on complex patterns -- like traces where an LLM call follows a retrieval, or traces with errors but no tool calls? Create multiple span queries and define relationships between them.
1. Define your first **Span Query**
2. Click **Add Span Query** (up to 5)
3. Use **Find Traces Matching** to combine them with operators: `AND`, `OR`, `NOT`, `->` (temporal), `=>` (parent-child)
* **AND** -- traces with spans matching both A and B
* **OR** -- traces with spans matching A or B
* **NOT** -- traces without spans matching the query
* **->** (Indirectly Calls) -- A starts before B
* **=>** (Directly Calls) -- A is the direct parent of B
* Combine with parentheses: `(A AND B) OR C`, `A AND NOT(B -> C)`
### Time filters
Use the **Time Selector** to focus on the period that matters. Choose presets, use the calendar, or type a custom range directly.
* **Presets:** Last 15 Min, Last Hour, Last 12 Hours, Last 7 Days, Last Month, Last 3 Months, Last 6 Months
* **Custom range:** Select "Custom" to pick a specific start and end date/time
* **Time zone:** Set your preferred timezone; it persists across sessions
***
## Saved Views
Found a useful filter + column setup? Save it so you don't have to rebuild it every time. Saved Views preserve your exact Tracing table configuration -- filters, columns, sort order, and time range -- so you and your team always come back to the same starting point.
Arize AX provides two built-in views: **Arize Default** (no filters) and **Recent Errors (15m)** (pre-filtered to `status_code = 'ERROR'`). You can't overwrite them, but you can fork them with **Save as new view**.
To create a view: set up the table how you want it (filters, columns, sort, time range). A **Save** button (disk icon) appears in the toolbar when you have unsaved changes. Click it and choose **Save as new view**. Views are shared per project. Each user can set their own **personal default** via the view's actions menu.
| Setting | Stored |
| -------------- | ------------------------------------ |
| **Filter** | Full query including subqueries |
| **Columns** | Visible columns and order |
| **Sort** | Column and direction |
| **Time range** | Preset or custom window and timezone |
***
## Columns
Not every column is relevant to every investigation. Customize which columns are visible using the **Columns** button in the table toolbar. Columns are organized into groups:
* **Span columns** -- TraceID, SpanID, Input, Output, Start/End Timestamp, Total Tokens, Status
* **Span Evaluations** -- scores and labels from your span-level evals
* **Session Evaluations** -- scores and labels from your session-level evals
* **Annotations** -- human labels and scores from your team
Toggle individual columns or select/deselect entire groups. Your column configuration is saved when you create a [Saved View](#saved-views).
***
## Export traces
Need the data outside Arize? Export trace data for evaluations, fine-tuning, or further analysis.
* **Export to Notebook** -- generates a prefilled Python snippet using the Arize SDK to export your data to a DataFrame. Copy it into a Jupyter notebook to start analyzing.
* **Export as CSV** -- downloads the top 10,000 rows currently displayed. Customize columns before exporting.
* **Configure Export via Agent (Skills)** -- opens the Arize Skills setup for exporting via your coding agent.
* **Configure Export via Code** -- shows CLI, Python SDK, and REST API snippets for programmatic export.
***
## Next step
You can explore individual traces and sessions. Now zoom out to see how your agents behave in aggregate: