> ## Documentation Index
> Fetch the complete documentation index at: https://docs.weflayr.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Import past calls
> Benchmark calls you logged before Weflayr, from a CSV export of Langfuse, Braintrust, LangSmith or any other tool.
From [Model benchmarks](/product/model-benchmarks), click **Import past data from CSV**, drop your file and check how its columns map to Weflayr's fields. The imported calls then show up when you [create a benchmark](/product/create-a-benchmark).
Not sure your export has the right shape? Give your file to your coding agent with the [formatting prompt](#formatting-prompt) (also behind **Copy prompt** in the import window): it converts the file to the format below.
## File format
A `.csv` file with a header row and one row per LLM call, up to 100 MB and 50,000 rows. Columns are matched to fields by name (case and separators do not matter), and you can change any match.
| Field | Required | Content | Matched column names |
| - | - | - | - |
| Call name | Yes | The call the row belongs to, e.g. `draft-reply`. You can also type one call name for every row. | `call_name`, `call`, `name`, `span_name` |
| Input | Yes | The request, as JSON in the OpenAI Chat Completions format: `messages`, and the `tools`, parameters and `response_format` it set. A list of messages alone works too. A call that makes tool calls needs its `tools`. | `input`, `prompt`, `messages` |
| Timestamp | Yes | ISO 8601, e.g. `2026-09-24T14:05:00Z`. Read as UTC without a timezone. | `timestamp`, `created_at`, `start_time` |
| Model name | Yes | e.g. `gpt-4.1-mini`, or `google/gemini-3-flash-preview` to also give the provider. | `model`, `model_name`, `provided_model_name` |
| Input tokens | Yes, or Usage details | Cached tokens included. | `input_tokens`, `prompt_tokens` |
| Output tokens | Yes, or Usage details | Reasoning tokens included. | `output_tokens`, `completion_tokens` |
| Usage details | No | Both token counts as JSON, as Langfuse exports them: `{"input": "17076", "output": "20"}`. Rows where it is empty are skipped. | `usage_details`, `usage` |
| Output | No | The answer, as JSON: an OpenAI assistant message, or a JSON string (`"billing"` with its quotes). | `output`, `completion`, `response` |
| Provider | No | e.g. `openai`, `anthropic`, `bedrock`, `vertex`, `azure`. Prices the call at that provider; read from the model name when empty. | `provider`, `provider_name` |
| Customer name | No | The customer the call was made for. | `customer`, `customer_name`, `user_id` |
| Run tags | No | A JSON object of tags to filter on, e.g. `{"plan": "pro"}`. | `tags`, `run_tags`, `metadata` |
The [call picker](/product/create-a-benchmark) lists calls made in the last 30 days: import recent calls, or pick another period in the Data step.
## Formatting prompt
Give this prompt to your coding agent with your export: it writes and runs a script that converts the file to the format above.
````markdown theme={null}
# Task: convert my LLM call export into a CSV Weflayr can import
Write a script that reads my export of past LLM calls and writes a CSV file Weflayr imports, then run it on my file. Ask me for the export, or a few rows of it, if you do not have it.
## Output file
- UTF-8, comma-separated, with a header row naming the columns below, exactly as written.
- One row per LLM call. Leave out the rows of my export that are not a model call, such as tracing spans with no model or no token usage.
- A cell holding JSON holds it as text, quoted as CSV requires.
- Leave the cell of an optional column empty when my export has no value for it.
## Columns
### call_name (required)
The call each row belongs to, such as draft-reply. A benchmark replays the rows of the calls it picks.
### input (required)
The request the call sent to the model, as JSON, in the OpenAI Chat Completions format: its messages, the tools the model could call, the parameters it set (temperature, max_tokens, top_p, stop, seed, reasoning_effort...) and, for a structured output, its response_format. A benchmark replays the call with them. A call that makes tool calls is refused without its tools. A call setting nothing but its messages can hold just the list of messages.
Example cell:
```json
{
"messages": [
{ "role": "system", "content": "..." },
{ "role": "user", "content": [
{ "type": "text", "text": "..." }
] }
],
"tools": [
{ "type": "function", "function": {
"name": "xxx", "description": "...",
"parameters": { "type": "object", "properties": {} } } }
],
"temperature": 0.2,
"max_tokens": 1000,
"response_format": { "type": "json_schema", "json_schema": {
"name": "xxx", "schema": { "type": "object", "properties": {} } } }
}
```
Extra fields are accepted, but not used.
### output (optional)
The answer the model gave, as JSON: an assistant message in the OpenAI Chat Completions format, or a string. Candidates are judged against it.
Example cell:
```json
{
"role": "assistant",
"content": "...",
"tool_calls": [
{ "id": "xx", "type": "function",
"function": { "name": "xxx", "arguments": "{}" } }
]
}
```
Extra fields are accepted, but not used.
### timestamp (required)
When the call was made, in ISO 8601, such as 2026-09-24T14:05:00Z. A time without a timezone is read as UTC.
### model_name (required)
The model that answered, such as gpt-4.1-mini, or its provider and model, such as google/gemini-3-flash-preview, in which case the Provider column is not read. A benchmark compares candidates with it when it compares them to production.
### provider (optional)
The provider the call was sent to, such as openai, anthropic, bedrock, vertex or azure. Its cost is computed at that provider's price. Left empty, the provider is read from the model name, at the price of the company that makes the model.
### input_tokens (required)
The number of tokens the call's input counted, cached ones included. Its cost and a benchmark's price are computed from it.
### output_tokens (required)
The number of tokens the model's answer counted, reasoning included. Its cost and a benchmark's price are computed from it.
### usage_details (optional)
The call's input and output tokens in one JSON object, as Langfuse exports them, in place of the Input tokens and Output tokens columns. A row whose usage details are empty, such as a span that called no model, is skipped.
Example cell:
```json
{ "input": "17076", "output": "20" }
```
Extra fields are accepted, but not used.
### customer_name (optional)
The customer the call was made for.
### run_tags (optional)
Tags to filter the calls by, as a JSON object of names and values.
Example cell:
```json
{ "plan": "pro", "region": "eu" }
```
````
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.