How to export data from Braintrust without losing experiments or scores
A renewal, a pricing change or a residency requirement can force a move off Braintrust on a short timetable. Logs, datasets and experiments can be exported from the Braintrust UI as JSON or CSV, and the BTQL API returns JSON or Parquet, but permission, timeout and paging limits decide how much data you can move in each pass. Those limits should shape the migration plan from the start, not appear after the project is already scheduled for closure. Confirm the current export formats in Braintrust's own documentation and in your account, since the details of each export path can change.
The export controls depend on the role your account holds in the Braintrust organization and project, so check that the people running the export have the permissions the export action requires before you start. For API exports, Braintrust's documentation describes a 30-second request timeout and paged results. Plan the export as a series of bounded queries, split by project, experiment or time range, and record the page position for each run so an interrupted job can resume without duplicates or gaps. Confirm the exact timeout, page size and required permissions in Braintrust's documentation and in your own account before you rely on them.
The export moves data, not configuration. UI settings such as saved views and online scoring setups, user access and role assignments stay behind, and evaluator code that runs inside your application must be copied from your repository into the new stack. Treat the export as incomplete until you have compared record counts per project, experiment and dataset against the source, opened sample files in the target tool, and confirmed that scores and metadata map to the new schema. Keep the Braintrust project readable until that comparison passes and your retention obligations are met. Ask Braintrust to confirm in writing how deleted data is handled before you delete anything.
What export paths Braintrust documents for logs, datasets and experiments
This table lists each data type you may need to take out of Braintrust, the export route the documented paths cover, the file format, and what to confirm before relying on it. Use it as a checklist: the UI and BTQL API routes are the documented options, but the request limits and paging behavior must be verified against Braintrust's current API documentation before any script is written. Treat the table as the start of an inventory, not a complete export plan.
| Data type | Export method | Format | Limits to confirm |
|---|---|---|---|
| Logs (traces and spans) | UI export or BTQL API | JSON or CSV in the UI; JSON or Parquet via the BTQL API | Confirm the 30-second request timeout and how paging works for large log volumes |
| Datasets | UI export or BTQL API | JSON or CSV in the UI; JSON or Parquet via the BTQL API | Confirm whether dataset records and their versions export together and how paging applies |
| Experiments | UI export or BTQL API | JSON or CSV in the UI; JSON or Parquet via the BTQL API | Confirm which experiment fields, such as inputs, outputs and metadata, appear in each format |
| Scores attached to logs or experiments | BTQL API (confirm UI coverage) | JSON or Parquet via the BTQL API | Confirm that scores are returned in the same request as their parent record |
| Metadata and tags on records | UI export or BTQL API | JSON or CSV in the UI; JSON or Parquet via the BTQL API | Confirm nested objects survive CSV flattening and how they map to your target platform |
| Permissions for the export action | Project role in Braintrust | Not applicable | Confirm which role your account needs to run the UI export and the API key scope for BTQL |
| Attachments and file references | Confirm with Braintrust | Not confirmed in researched facts | Confirm whether referenced files are included in an export or must be fetched separately |
What does not come out with the data and how to rebuild it
A bulk export carries the records you generated, but much of what made the Braintrust project work lives outside the data. Each card below names one class of object that typically stays behind, the workaround for the target platform, and what to confirm with Braintrust before you assume coverage.
Scorer and evaluator code
Scorers that run in your application or CI pipeline are code, not rows in an export. Their logic, thresholds and version history usually sit in your repository, but any scorer defined only inside the Braintrust UI is not guaranteed to come out as source. Copy the code into your team's repository, pin the versions you used for baseline runs, and rerun them against exported datasets in the new platform to confirm scores match. Ask Braintrust which scorer definitions the export includes.
Prompt versions and playground settings
Prompts edited only in the Braintrust UI, along with model, temperature and playground parameters, may exist only in the platform. Record every production prompt in version control with its model and parameters, and tag the commit that matches each experiment baseline. Without this, a prompt that produced a historical score cannot be reproduced. Confirm with Braintrust whether prompt versions and playground state are included in the export or only referenced by ID.
Project and user permissions
Roles, project-level access and who could view or export logs are configuration, not dataset content. Before the contract ends, document each team's role, the people who held owner or admin rights, and which projects contained sensitive prompts or user data. Recreate that access model in the target platform, such as Langfuse project-level RBAC on its Enterprise license key, and treat it as a separate review item. Confirm with Braintrust that permission settings are not carried in the export.
Dashboards and alert rules
Dashboards, saved views and alert rules show how your team watches quality over time, and they rarely come out as data. Screenshot or list the metrics, filters, thresholds and notification targets each dashboard uses. Rebuild them in the target platform's dashboards or in your existing Grafana or alerting stack, then check that a known regression triggers the alert. Confirm which view definitions Braintrust exports.
Integrations configured in the console
Connections to model providers, data stores, CI webhooks and notification channels are set in the Braintrust console and hold credentials you will not export. Inventory every integration, note which application SDK or environment variable sends traces, and plan replacement keys and endpoints. Update each application to send traces to the new platform, using its SDK or OpenTelemetry exporter, and retire old API keys only after both systems have run in parallel.
Evaluation gates and CI configuration
Pull request checks, scheduled eval jobs and promotion gates that call Braintrust are workflow definitions in your CI system, not platform data. List each job, its trigger, the dataset and scorer it calls, and the pass threshold. Move these definitions into your repository and point them at the new platform, so a release gate keeps working on day one.
Sequence for a complete export from Braintrust
This sequence turns a Braintrust export into a verified archive. Each project in scope is inventoried, pulled in formats you have tested, recorded in a checksummed manifest, and checked against the source before anything is deleted. Each step closes with a check you can record, so the final archive can be audited.
Inventory projects, datasets and experiments
The platform or ML lead lists every Braintrust project, dataset and experiment the business still needs, including logs kept for audit, evaluation history and prompt versions. Note the record count shown for each item, label it as migration, retention or disposable, and choose the format for each (JSON, CSV or Parquet). Done when the data owner signs off on the list and each row has a named destination.
Confirm roles and the API key
Check that your Braintrust user can see the export option on every project in scope. Create the API key under a shared service account with read access to those projects, and record who owns the key and how it will be revoked after the export. Done when one BTQL read against a single project returns data with no permission error, and the account settings you checked match your record.
Export a small test set first
Choose one project and one small experiment, then export them from the UI as JSON and CSV and through the BTQL API as JSON and Parquet. Open each file in the tools your team will use, such as a notebook, a spreadsheet and a Parquet reader. Check column names, nested scores and metadata fields, and timestamps. Done when every format opens and the fields match what you see in the Braintrust UI.
Run paged BTQL pulls for large logs
Split large logs into time windows or pages that each complete within the 30-second request timeout. Save each page's query, cursor or window bounds and status to a checkpoint log. If a page fails, resume from the last saved checkpoint so the rest of the pull is not repeated. Done when every planned window has a completed page and the log shows no gaps or overlaps between windows.
Store raw files with checksums and a manifest
Write the files exactly as received into an encrypted storage bucket with restricted access, and do not edit them. Compute a SHA-256 checksum for each file and build a manifest that lists the file name, source project, query or filter, date range, row count, checksum and the person who ran the export. Done when a second person can recompute the checksums and match every entry in the manifest.
Compare row counts and sample records
For each experiment and log set, compare the exported row count with the count for the same filter in Braintrust. Spot-check random records, including failed and edge-case rows, for scores, metadata, timestamps and input and output payloads. Done when each count matches or the difference is explained in writing, and every sampled record matches the source.
Confirm the output opens in your own tooling
Load the files into the analysis or evaluation environment you will use after the contract, such as a notebook, a database or the destination platform's import path, and confirm that the data appears as expected. No step is complete until this check passes. Have the data owner sign off before any Braintrust project is deleted, and keep the manifest with the archive.
Choosing between the UI export and the BTQL API
A small project with a modest log history is usually exported by one admin from the Braintrust UI. The export runs under that user's own account, so the person needs project-level access that allows them to view the logs, datasets or experiments being exported. Confirm the exact role and permission names in Braintrust's documentation and in your organization's settings, because they can change between product versions.
- Who runs it. One project admin, from a single session, using a named account that appears in your access records.
- Formats. The UI offers JSON or CSV for logs, datasets and experiments. Check which objects each format covers before relying on it as your only copy.
- Typical failure modes. A partial download when the view is filtered or paged, and fields that go missing in CSV. Confirm whether nested metadata survives the CSV format.
- Audit record. The export date, project name, object types, filters applied, format, the row count shown in the UI and a checksum of the stored file.
Compare the row count in the file with the count visible in the UI before you delete anything.
A large log history cannot reasonably depend on one browser session. Scripted export through the BTQL API lets an engineer page through results in chunks, store each page and resume after a failure. Each request is subject to a documented timeout, so the script should keep page sizes modest and treat any timed-out request as incomplete, retrying only that page.
- Who runs it. A platform or data engineer with an API key scoped to the project, running the script from a host or CI runner inside your network.
- Formats. BTQL returns JSON or Parquet. Choose the format your analytics tooling reads, and confirm the output options in the current BTQL reference.
- Typical failure modes. Requests that exceed the documented timeout, pages that skip or repeat rows when the cursor is unstable, and missing fields when the query selects a narrow column list.
- Audit record. The script version, the query text, page boundaries, row counts per page, timestamps, a retry log and a hash for every stored file.
Compare the total row count from the query with the sum of stored pages before treating the export as complete.
A team that must show auditors or residency reviewers how data left the platform needs an export it can run again and explain. The script, the permissions and the stored evidence matter as much as the data itself. Keep the export under version control, run it under a service identity with a documented permission set, and store outputs in the region and bucket your data residency commitments name.
- Who runs it. A named owner plus a service identity, with a change record for every run.
- Permissions. A dedicated role limited to export on the named projects, reviewed on a schedule and removed when a project changes hands.
- Typical failure modes. Schema drift between runs, where the same query returns different fields, and output written to a location outside the approved region.
- Audit record. The Git commit of the script, a run ID, the identity used, the query and filters, object counts, checksums, the storage location and the approver of each run.
Ask Braintrust to confirm in writing which export options, retention limits and access logs apply under your contract before you rely on them as evidence.
What to plan before the Braintrust renewal or termination date
Six items close the gap between an export that ran and a migration that can be signed off. Each has one owner and one piece of evidence, so nothing is deleted or switched off on the strength of an unchecked file. Confirm every date and term with Braintrust before you rely on it.
Confirm notice and renewal dates
Procurement should read the order form and master agreement for the renewal date, the notice period and any auto-renewal clause, then confirm those dates with Braintrust in writing. Internal calendars often drift from the contract, and the export window is only as long as the earliest notice deadline. Record the confirmed dates in the migration plan with the email or letter that confirmed them.
Freeze project deletion
Engineering and procurement should agree that the Braintrust project stays intact, including logs, datasets and experiments, until verification is signed off. Deletion is the step that cannot be reversed, so the freeze belongs in the change calendar and in the offboarding ticket. Remove write access for application keys only after the final export is verified, so traces still arriving are captured.
Set a retention period for archives
Security and compliance should decide how long exported JSON, CSV and Parquet files are kept, who can read them and where they are stored. Exports can contain prompts, model outputs and user content, so they inherit your data classification. Evidence to close this item is an approved retention schedule and a storage location with access logging enabled.
Name the reviewers with access
Engineering leads should list the people who must check exported output, such as the owners of evaluators, datasets and scores. Give them read-only access to the archive and to the target system only, and log who reviewed which sample. Evidence is a signed access list and a reviewer sign-off per dataset, which together show the export was checked by people who know what the data should look like.
Update instrumentation still sending traces
Engineering should inventory every service that sends traces to Braintrust through its SDK, proxy or OpenTelemetry exporter, and plan a change for each. Services that keep writing after the export will create data that is missing from the archive. Evidence is a repository search that shows no remaining Braintrust exporter configuration, plus a staging test that confirms traces arrive at the new platform.
Schedule a parallel-run window
Engineering and compliance should agree on a period in which both Braintrust and the self-hosted platform receive the same traces, and compare scores and experiment results. The window ends when evaluation results match within the tolerance the team sets in advance. Evidence is a written comparison report covering the agreed datasets, signed by the owners before cutover.
Why verification comes before deleting the Braintrust project
Deleting a Braintrust project is the one step you cannot take back, so the export must pass a written verification check before anyone deletes anything. Treat the export as a claim that needs evidence: the archive exists, it is complete, and the values in it match what Braintrust held. Record the results in a short document that names the project, the export date, the person who ran each check and the archive location, so the evidence survives after the project is gone. The core checks are straightforward. Compare record counts for every dataset and every experiment against the counts shown in the Braintrust UI or returned by the BTQL API at export time, and note any difference with an explanation. Then compare fields at the record level: inputs, outputs, scores, metadata and tags should match for a sampled set and for every record where a score or label matters to a gate in your CI pipeline. Finally, read a sample of records back from the archive with a script, not by eye, and confirm that the files open with the expected schema, whether the export used JSON, CSV or Parquet.
Before you schedule deletion, confirm in writing with Braintrust how long your data remains available after the contract ends, and whether you can still export after termination. Do not rely on any retention period that has not been confirmed in writing, and do not assume that a grace period exists because a previous customer had one. Ask for the answer in the renewal or termination correspondence and file it with the verification record. Finish with a sign-off from the business owner of the evaluation program, not only the engineer who ran the export. That person accepts the archive as the system of record for past experiments and confirms which open-source platform will serve as the target. Only after that sign-off and a passing check should anyone delete the project. Keep the archive and the verification record for as long as your own retention policy requires, since neither depends on Braintrust remaining active.
Questions buyers ask before exporting data from Braintrust
Can our team export our Braintrust data without outside help?
Yes, for a small project. Logs, datasets and experiments can be exported from the Braintrust UI as JSON or CSV, which covers modest history without custom code. Larger histories need scripting against the BTQL API, which returns JSON or Parquet. Requests are subject to a 30-second timeout, so the script must page through results in batches and resume cleanly after a failure. Your own engineers can do this if they have API experience and time to test. If the history is large or the team is stretched, a fixed-scope engagement with DeployOpen can cover the export script, validation and handover, with the scope and deliverables agreed in writing before work starts.
What makes a Braintrust export take more effort?
Four factors drive the effort more than anything else. The first is log volume, because more traces mean more pages, more storage and longer validation. The second is the number of projects, since each one needs its own export run, naming convention and checks. The third is custom scorers: their logic lives in code or configuration that must be documented and re-created in the destination platform, not just copied. The fourth is the number of downstream consumers, such as dashboards, notebooks, CI gates and internal reports, each of which reads from a specific place and must be repointed. Illustratively, a team with three projects and two scorers that feed a CI gate has a much smaller task than one with twenty projects and a dashboard built on raw logs.
What access and resources does a Braintrust export require?
You need four things in place before starting. First, an account in Braintrust with permission to use the export controls and call the API for every project in scope, which may require an administrator to grant it. Second, storage for the output files, such as an S3-compatible bucket or an encrypted network share, sized for the full history with room for re-runs. Third, an engineer who can write and run the BTQL script, handle paging and retries, and store API keys in a secrets manager rather than in code. Fourth, a reviewer who did not write the script and who checks row counts, field completeness and a sample of records against the source. Confirm the exact permission names and export limits in Braintrust's current documentation or with your account team.
How long will exporting our Braintrust data take?
The duration depends on the volume of logs, datasets and experiments, the number of projects, and how many requests the paging logic needs to complete. No single figure applies to every account, so the reliable approach is to measure first. Choose one representative project, run the full export path including paging, validation and storage, and time each step. Then multiply by the number of projects and add time for failures, retries and review. Ask your Braintrust account team whether any rate or volume limits apply to your plan, because those can change the schedule. Once you have a measured result, the timeline in a written scope can be based on your own numbers.
Can Braintrust data move directly into Langfuse or Opik?
Not as a one-click import. Braintrust exports must be mapped to the data model of the destination before they can be loaded. Traces and spans need to become Langfuse traces and observations or Opik traces and spans, datasets need matching item structures, and scores need to be attached to the correct trace or experiment. Metadata fields often need renaming or flattening. Applications that send live traffic also need their instrumentation changed, either through the Langfuse SDK or OpenTelemetry, or through Opik's SDK or @track decorator. Before writing the mapping, check the current import options in each platform's documentation, such as the Langfuse self-hosting guide for deployment prerequisites, and test the mapping on a sample project.
Which parts of a Braintrust export are one-time and which recur?
The export run itself is one-time work: scripting, test runs, the full extraction, mapping and validation. Those costs are paid once, though they may be repeated if the mapping changes and the data must be re-exported. Recurring costs begin after the export. Archive storage is charged for as long as you keep the files, and retention periods set by your compliance team determine how long that lasts. If you move to a self-hosted destination, the running costs of that platform recur too. For Langfuse, these include PostgreSQL, ClickHouse, Redis or Valkey, and S3-compatible storage, plus the staff who patch and back them up. Ask for each recurring component to be listed separately in any quote.
Should we delete the Braintrust project once the export finishes?
Not until verification is complete and the retention obligations are settled. Confirm that row counts match for logs, datasets and experiments, that a sample of records matches field by field, and that scorer definitions, prompt versions and evaluation baselines have been saved in a readable form. Check your contract for data return and deletion terms, and check internal or regulatory retention rules for the data you hold. Deleting the project removes the source of truth, so keep the verified export in a controlled archive until the destination has been used for a full evaluation cycle. Record who approved the deletion and when, so the decision can be audited later.
How DeployOpen scopes and delivers a Braintrust data exit
DeployOpen treats a Braintrust data exit as a fixed-scope engagement: we agree in writing which logs, datasets and experiments move, where they land and how completeness is checked before anything is deleted. We then build and document the export pipeline inside your own infrastructure, so the evidence trail stays with your team.
How we scope
- Inventory which projects, logs, datasets and experiments must leave Braintrust before the contract ends.
- Confirm the roles and API permissions the export needs, and who in your organization approves them.
- Agree in writing the target store, paging approach for the 30-second request timeout, and the verification criteria.
How we build
- Build export scripts that page through BTQL API results and write JSON or Parquet into your own storage.
- Test each export against record counts and sample comparisons, and log failed pages for retry.
- Document the mapping of scores, metadata and dataset versions so the data remains usable after migration.
How we hand over
- Deliver runbooks, scripts and a reconciliation report showing what was exported and what was verified.
- Walk your engineers through the checks that must pass before the Braintrust project is deleted.
- Provide a written record of storage locations, retention settings and access controls for your audit file.
How we support
- Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
- Ongoing support, upgrades and continuous testing are available as a retainer after handover.
- Ask for a quote that itemizes scripting, verification, documentation and any retained support separately.

