How to export data from Braintrust before your contract ends

Teams leaving Braintrust need to know which logs, datasets and experiments they can take out, in which formats, and what must be verified before the project is deleted. This guide covers the documented export paths only.

On this page

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 typeExport methodFormatLimits to confirm
Logs (traces and spans)UI export or BTQL APIJSON or CSV in the UI; JSON or Parquet via the BTQL APIConfirm the 30-second request timeout and how paging works for large log volumes
DatasetsUI export or BTQL APIJSON or CSV in the UI; JSON or Parquet via the BTQL APIConfirm whether dataset records and their versions export together and how paging applies
ExperimentsUI export or BTQL APIJSON or CSV in the UI; JSON or Parquet via the BTQL APIConfirm which experiment fields, such as inputs, outputs and metadata, appear in each format
Scores attached to logs or experimentsBTQL API (confirm UI coverage)JSON or Parquet via the BTQL APIConfirm that scores are returned in the same request as their parent record
Metadata and tags on recordsUI export or BTQL APIJSON or CSV in the UI; JSON or Parquet via the BTQL APIConfirm nested objects survive CSV flattening and how they map to your target platform
Permissions for the export actionProject role in BraintrustNot applicableConfirm which role your account needs to run the UI export and the API key scope for BTQL
Attachments and file referencesConfirm with BraintrustNot confirmed in researched factsConfirm 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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

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.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.