How to export your data from Doppler before your contract ends
Secrets can be exported from Doppler one config at a time, either with the Doppler CLI or with the download API. Projects, access settings, sync configurations and audit history are not part of that export, so each needs its own inventory before a renewal, pricing change or residency decision forces a move. The download endpoint returns a config's secrets as json, dotnet-json, env, yaml, docker or env-no-quotes, and accepts optional name transformers such as lower-snake. Doppler's documented platform limits cap a config at 1,200 secrets and set per-token read limits of 120 requests per minute on Developer, 240 on Team and 480 on Enterprise, so large estates should plan batched runs across configs.
The CLI has a safer default than many teams expect. Running doppler secrets download without the --no-file flag writes an encrypted fallback file rather than printing values, but Doppler's documentation strongly recommends against saving plain-text secrets to disk. Its examples use process substitution with Docker and kubectl so values never touch the file system. Dynamic secrets are excluded unless include_dynamic_secrets is set on the API call, and those leases expire after 1,800 seconds by default, so confirm with Doppler how dynamic credentials should be rotated at the source rather than copied out. Before the export, ask your Doppler account team to confirm which items fall outside the download path in your plan, and record the export as a documented step in your migration plan.
Treat every export file as sensitive material. Store it in an encrypted location with restricted access, record which configs were exported and by whom, and delete plain-text copies once the destination has been verified. Only the documented export paths are covered here. If a Doppler feature has no documented export route, ask Doppler in writing how to retrieve it, and plan to recreate it by hand in the target platform. The destination design, sibling migration pages and the handling of syncs are covered in those sections.
Which Doppler data you can export and how
This table shows which Doppler data types can be pulled out, the formats and limits that apply, and what the facts do not cover. Read each row as a constraint to plan around before you script a bulk export across projects and configs.
| Export item | What the facts support | What to confirm before you start |
|---|---|---|
| Secrets in one config | Download endpoint returns a config's secrets as json, dotnet-json, env, yaml, docker or env-no-quotes | Which formats your downstream tools need and whether each config has a clean export path |
| Name transformers | Optional transformers such as lower-snake and dotnet-env rename keys during download | Whether renamed keys still match what your applications and OpenBao paths expect |
| CLI download | doppler secrets download saves an encrypted fallback file unless --no-file is set | Who holds the encryption key for the fallback file and where it is stored |
| Secrets per config | Platform limits allow up to 1,200 secrets per config | Whether any config in your workspace is close to this ceiling and needs splitting into batches |
| Read rate by plan | Per-token secrets reads: 120 requests per minute on Developer, 240 on Team, 480 on Enterprise | Your plan tier and how many configs a scripted export will read per minute |
| Dynamic secrets | Returned only when include_dynamic_secrets is set, issuing leases that expire after 1,800 seconds by default | Whether the lease window suits your downstream workloads and whether a static copy is needed instead |
| Plain-text output | Doppler advises against writing plain-text secrets to disk and shows process substitution as an alternative | Where any exported file will be stored, who can read it and how it will be deleted |
What does not come out in a secrets download
A config download returns secret values and, when asked, dynamic secret leases. It does not carry the structure around those values or the records about who touched them. Before you treat a download as a complete export, account for the items below and decide how each one will be captured.
Project and environment structure
The download is scoped to one config, so the hierarchy of projects, environments and inherited configs is not in the file. Doppler's documentation on accessing secrets describes how configs relate to environments, which is the model you need to rebuild. Record each project, its environments and the config names in a spreadsheet or repository before you export. Confirm the current behavior for inherited values with Doppler's documentation, since an exported config may show the resolved value rather than its source.
Sync targets and integrations
Syncs that push secrets into GitHub, cloud platforms or Kubernetes are configuration in Doppler, not secret values, so the download does not list them. When you move workloads, every destination that receives a secret from Doppler must be found and rewired. Review each project's integrations in the dashboard and write down the target, the secret names it maps and who owns the destination. Confirm the list of integration types against Doppler's current documentation.
Access roles and service tokens
Who can read a config, which service tokens exist and what each token is allowed to read are controls, not secrets, and they stay in Doppler. A new platform will need its own identities, so you cannot copy these grants across. Export the list of members and service tokens from the dashboard, mark which ones belong to CI jobs or production workloads, and plan the replacement identity for each. Revoke tokens only after the new consumer is confirmed working.
Audit logs and access history
Activity logs show who read, changed or downloaded secrets and when. They are often the evidence an auditor or incident responder asks for, and they do not come out in a secrets file. Decide how long you must keep them, export what the dashboard offers and ask Doppler support for account-level records that the dashboard does not show. Confirm retention and export options in writing before you rely on them.
Version history and rotation state
A download shows the current value only. Earlier versions, the date each secret was last rotated and any pending rotation schedule are not part of the file. Note the rotation date for high-value credentials such as database passwords and API keys, because the new platform will start its own history on import. Ask Doppler support whether historical versions can be retrieved for your account before the cutover.
Dynamic secret leases
Dynamic secrets appear in a download only when include_dynamic_secrets is set, and each lease expires after 1,800 seconds by default. Leases already issued do not move to a new system and are not a reusable export. Rebuild dynamic credentials on the target platform and let existing leases run out. Confirm the lease behavior with Doppler's current API reference before scheduling any cutover.
Handling encrypted fallback files and plain-text exports
The safest default is to never write Doppler secrets to disk in readable form. Running doppler secrets download without the --no-file flag does not print values. Instead, the CLI saves an encrypted fallback file, which Doppler uses so that the CLI can keep working when it cannot reach the API. Treat that file as a cache, not as an export. Confirm in your own environment where the CLI writes it, who can read that location, and how long it stays there, and check that your team does not copy it into backups, repositories or shared drives. Use --no-file in every script that does not need the fallback, so a pipeline never leaves an artifact behind by accident.
Doppler's documentation strongly recommends against downloading secrets in plain text to the file system. Its examples for Docker and kubectl use process substitution instead, so the values are passed directly to the consuming command and never land on disk. The pattern is to pipe doppler secrets download --no-file --format env (or the format your consumer expects) into the tool that reads it, and to confirm the exact syntax against the Doppler CLI guide before you adopt it. Once the pattern is in place, set controls on both ends: workstation disk encryption and screen locks, shell history and process listings kept clear of secret values, restricted service tokens scoped to a single config, and destinations that do not write the values to logs or container layers.
Plan for the plain-text exports you cannot avoid, such as a one-off migration into another vault. Limit who may run the export, keep the output in an encrypted volume that is deleted as soon as the import succeeds, and record the export in your change log without recording the values. Before any migration, ask your DeployOpen team or your own platform engineers to confirm whether the destination system accepts the Doppler export formats directly or needs a transformation step, since that step is where plain text most often lingers. Doppler's API also returns dynamic secrets only when the request sets include_dynamic_secrets, so decide explicitly whether leases should be exported at all, because they expire on their own.
Export sequence for a complete Doppler extract
This sequence produces a complete, verified copy of every Doppler config in scope, with dynamic secrets captured separately and all files kept in an encrypted location. It gives you a record you can check against the source before you change anything in Doppler.
Inventory every project and config
Before exporting anything, list each project and each config under it, including the root and branch configs for every environment. Someone with workspace access in Doppler should produce this list from the dashboard or the CLI, and record the secret count shown for each config. That count becomes your baseline for verification. Mark any config that holds dynamic secrets, since those need separate handling. The step is done when you have a written inventory with one row per config and a count beside it.
Authenticate with a scoped token
Create a service token limited to the single project and config you are exporting, and use it for that export only. Doppler's CLI can be authenticated with a token, and the download API accepts the same credential as a bearer token. Keep the token out of shell history and CI logs, and record which person or system owns it. Confirm that the token can read the config by running a dry test that returns a secret name without printing values. The step is done when the test succeeds with the scoped token and fails against a config you did not grant.
Export each config with a name transformer
Export one config at a time using the CLI command
doppler secrets downloador the download endpoint, choosing a format such as json, env, yaml or docker. Select a name transformer that matches the naming rules of your target system, for example lower-snake, and keep the same choice for every config so the outputs stay consistent. Omit the--no-fileflag so the CLI writes an encrypted fallback file instead of printing values to the terminal. The step is done when each config has one output file and the file name records the project, config and date.Pace requests under the per-token limit
Doppler sets a per-token read limit of 120 requests per minute on Developer, 240 on Team and 480 on Enterprise, so check which plan your workspace is on before you start. Run exports sequentially or with a small fixed delay between calls, and watch for rate-limit responses that tell you to retry later. Any config near the 1,200 secrets-per-config platform limit should be exported in one call, not split across requests. The step is done when every config has completed without a rate-limit error that you failed to retry.
Capture dynamic secrets separately
The standard download returns static values only. To capture dynamic secrets, request them explicitly with the include_dynamic_secrets option, and record that each returned lease expires after 1,800 seconds by default. Treat these values as short-lived: they are useful for documenting which systems used dynamic credentials, but you should not expect them to work after the lease ends. Keep this output in its own file, separate from static secrets, so it is not mixed into the migration set. The step is done when each dynamic secret is listed by name and owning system in the inventory.
Store outputs in an encrypted location
Move every fallback file into an encrypted store that your organization controls, such as an encrypted volume or a secrets vault with restricted access. Confirm that the location enforces access by named roles and that file transfers use encrypted channels. Avoid plain-text copies on laptops, shared drives and CI runners, and delete any temporary plain-text files immediately after use. Doppler's documentation strongly recommends against writing plain-text secrets to the file system, so where a tool needs a file, prefer process substitution. The step is done when the store's access list is recorded and no unencrypted copies remain on local disks.
Verify counts and sample values
Compare each exported file against the baseline from the inventory: the number of keys must match the secret count recorded for that config. Then pick a sample of keys, including the longest and most recently changed ones, and confirm their values match the source by reading them through a scoped token again. Record any mismatch, missing key or unexpected empty value in a discrepancy log and resolve it before you rely on the export. The step is done when counts match for every config, the sample check passes, and the log shows zero open discrepancies.
How to verify that every config made it out
A key count check is the simplest proof of completeness. Doppler's platform limits allow up to 1,200 secrets per config, so a config near or at that ceiling deserves particular attention. Compare the number of secrets in each Doppler config with the number of entries in the exported file, and with the number of keys your target system reports after import. A mismatch means something was dropped, duplicated or filtered out during export.
- Count per config: Record the secret count for every config before export, not just for the configs you expect to be large.
- Compare the export file: Count the top-level keys in each JSON or YAML file and confirm the number matches the Doppler count.
- Check for silent skips: Look for keys that were empty, reserved or excluded by your export command, and log each exception.
- Repeat after import: Count keys in OpenBao KV paths or Infisical environments once the import finishes.
- Flag near-limit configs: Note any config approaching 1,200 secrets so it can be exported and checked in a separate step.
Keep the counts for each config in the migration record, with the date and the person who ran the check.
Counts show that keys arrived, but not that the values are correct. Spot checks compare selected values between Doppler and the target system. Choose a sample that includes the most sensitive configs, the longest values, values with special characters such as quotes, equals signs and newlines, and any values that are base64 encoded or multi-line certificates. Compare them through a secure channel, and never paste production values into tickets, chat or shared documents.
- Sample by risk: Select production and payment-related configs for a larger sample than development configs.
- Cover edge characters: Include values with quotes,
$signs, trailing whitespace and multi-line content. - Compare hashes: Compare SHA-256 hashes of each value on both sides so plain values never leave their systems.
- Record the method: Note which keys were sampled and how they were compared, not the values themselves.
- Escalate mismatches: Treat any mismatch as a stop condition until the cause is understood.
The result to record is the list of sampled key names, the comparison method and the outcome for each.
Format checks confirm that the file your pipeline reads matches what it expects. Doppler's download endpoint returns a config's secrets as json, dotnet-json, env, yaml, docker or env-no-quotes, and optional name transformers such as lower-snake or dotnet-env change key names. A transformer applied in one export and omitted in another produces keys that look similar but do not match, which breaks applications silently.
- Record the exact format: Store the format and transformer used for each export as part of the run record.
- Parse the file: Confirm each file parses with the expected parser before it is loaded anywhere.
- Check key names: Compare transformed key names against the names your applications and manifests reference.
- Check quoting: For env output, confirm quoted and unquoted values are handled as your loaders expect.
- Use one format per target: Keep one export format for each target system to avoid mixed results.
Record the format, transformer and parser result for every config so the team can reproduce the export.
Dynamic secrets need separate treatment because they are not stored values. Doppler's download API returns dynamic secrets only when include_dynamic_secrets is set, and those leases expire after 1,800 seconds by default. An export taken without that flag omits them entirely, and an export taken with it contains credentials that stop working on schedule. The check confirms which dynamic secrets were in scope, how they were issued and that none were copied into a static store as if they were permanent.
- Inventory dynamic secrets: List every dynamic secret source per config before export.
- Confirm the flag: Verify whether include_dynamic_secrets was set for each export and record the result.
- Check lease expiry: Confirm no exported lease was written as a long-lived static value.
- Recreate at the target: Confirm the target system issues its own dynamic credentials with leases and revocation.
- Test revocation: Revoke one test lease in the target system and confirm the dependent service fails as expected.
Record the dynamic secret inventory, the flag setting and the revocation test result.
A restore test proves the exported data works where it is going. Load a copy of the export into a non-production target, then start a representative application or pipeline and confirm it reads the secrets it needs. Doppler's documentation strongly recommends against writing plain-text secrets to the file system, so run the test with the same safeguards used for the real export, such as an encrypted fallback file or process substitution, and remove any staging copies afterward. Do not treat this as a substitute for a dry run of the migration itself, but use it to confirm that the target is correctly configured.
- Use a non-production target: Restore into a separate OpenBao cluster or Infisical instance first.
- Start a real consumer: Run one application or pipeline that depends on the restored secrets.
- Confirm access controls: Check that policies or roles allow only the intended identities to read each path.
- Remove staging copies: Delete any temporary plain-text files and confirm the deletion.
- Document the rollback: Record how the team would return to Doppler if the restore fails.
Retain the restore test results, the consumer tested and the access check outcome as the final evidence set, and confirm with your auditors or compliance team which records they require.
What to plan before Doppler renewal or termination
Most of the work in leaving Doppler happens before the export runs. The decisions below connect the inventory of what is exported, the platform that receives it, and the rotation, sync and retention work that follows, so none of them is left until the final week of the contract.
Build the export inventory and name an owner
List every project, environment and config, then record which ones feed production, CI or cloud syncs and which hold dynamic secrets. Each config should have one named owner who signs off that its export is complete. Check the count of secrets per config against the platform limit of 1,200 so no config is split or missed during export.
Choose Infisical or OpenBao
Infisical keeps a project and environment model close to Doppler's, with a CLI, Kubernetes operator and secret syncs. OpenBao uses path-based KV, policies and dynamic secrets, which means mapping projects to mounts and policies by hand. Decide which model your teams will operate before exporting, since the file format you choose depends on it.
Plan rotation once secrets leave Doppler
An export proves that values were copied, not that they are safe. Plan to rotate database passwords, API keys and signing keys after cutover, and revoke Doppler service tokens so old copies stop working. Schedule rotation by system owner so that application restarts and dependent services are coordinated and not improvised.
Repoint syncs and integrations
Inventory every Doppler sync, CI job, Kubernetes integration and cloud platform that reads secrets. Each one needs a new source, a new credential and a test run on the target platform. Confirm dynamic secret consumers too, since leases issued by Doppler with include_dynamic_secrets expire after 1,800 seconds by default and must be reissued from the new platform.
Set retention and deletion for exported files
Decide where exported files may live, who can read them and how long they are kept. Store encrypted fallback files only on approved hosts, and delete plain-text exports after import is verified. Record the deletion date and method in your change log so the export does not become an unmanaged copy of every secret.
Request Doppler's data return and deletion terms in writing
Ask Doppler, in writing, for its data return format, the timeline for returning data after termination, and its commitment to delete your secrets, logs and backups from its systems. Ask for the deletion confirmation in writing as well. Confirm these terms against your contract before the notice period closes, since the contract, not documentation, governs them.
Questions teams ask before exporting from Doppler
How much effort does a full Doppler export take?
Effort scales with the number of configs, how many secrets each one holds, and how much of the estate depends on Doppler at runtime. Doppler caps each config at 1,200 secrets, so the count of configs and secrets is the first thing to measure. Dynamic secrets, syncs to CI or cloud platforms, and per-environment access rules add work because each one must be re-created or re-pointed at the new platform. Team size matters because someone must confirm every consumer of every config. No duration is given here; ask your DeployOpen contact or a vendor to size the work from an inventory of your own configs, syncs and consumers.
Can an internal team export from Doppler without a partner?
Yes, a capable internal team can run the export itself, because the CLI and download API are documented and the task is mostly mechanical. The harder part is the surrounding work: inventorying which services read which configs, replacing syncs and dynamic secrets, and proving that nothing was left in plain text. Teams that lack spare platform or security capacity during a renewal window often bring in outside help for the inventory and cutover checks. DeployOpen plans, implements and documents this work under a written, fixed scope when a client chooses that route.
What access does the export need from Doppler and our infrastructure?
The export needs a Doppler token with read access to every project and config in scope, and that token should be scoped to the minimum set of configs. Doppler applies per-token read limits of 120 requests per minute on Developer, 240 on Team and 480 on Enterprise, so plan the run around those limits. On the target side, the team needs access to the self-hosted platform, its storage and its secret paths, plus access to any runtime that will receive secrets. Name an owner who approves each config move and who signs off the cutover. Confirm token scopes and limits against your own plan in Doppler.
Should exported files be written to disk or kept in memory?
Keep exported values off disk where you can. Doppler's documentation strongly recommends against downloading secrets in plain text to the file system and shows process substitution with Docker and kubectl so values never touch the disk. Running doppler secrets download without --no-file saves an encrypted fallback file instead of printing secrets, which is safer than plain text but still needs a defined retention and deletion step. Record each export, who ran it, and when the files were destroyed, because any plain-text copy becomes a new secret store to protect.
How do dynamic secrets and leases affect the export?
Dynamic secrets are not simply copied out. Doppler's download API returns them only when include_dynamic_secrets is set, and it issues leases that expire after 1,800 seconds by default. An exported lease is therefore a short-lived credential, not a stored value. The migration should instead recreate the dynamic secret at the new platform, such as an OpenBao database secrets engine, and revoke the Doppler-issued leases once consumers have switched. Verify the expiry behavior in Doppler's API reference before you rely on it.
What should we get from Doppler in writing before exporting?
Ask Doppler for written confirmation of the export and download features available on your plan, the per-token rate limits, the 1,200 secret per config ceiling and any changes to them, and the handling of dynamic secret leases. Also request the data retention and deletion terms that apply after you cancel, the format and completeness of any export you request, and the support window during migration. Confirm terms in your contract rather than relying on documentation alone, and keep the written answers with your migration record.
What evidence should the export leave behind for auditors?
Keep a record of each config exported, the export method, the operator, the date, the count of secrets moved, and the destination. Store proof that plain-text files were deleted and that Doppler tokens used for export were revoked. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports or certifications; independent auditors and certification bodies make those determinations. Ask your auditor which evidence format they expect before the export starts.
How DeployOpen scopes and delivers a Doppler exit
DeployOpen treats the export from Doppler as a scoped piece of work inside a larger migration: we agree which projects, configs and dynamic secrets move, how they are handled on the way out, and where they land. The work runs in your own infrastructure, with the export, transfer and verification steps documented so your team can repeat or audit them.
How we scope
- Inventory every project and config in scope, and list the secrets count per config against the 1,200 secrets per config limit
- Record which exports need dynamic secrets, which need plain-text files and which can use process substitution
- Agree the written scope, deliverables and timeline before any export runs, since most engagements are fixed-scope
How we build
- Script config-by-config exports with the Doppler CLI or download API, sized to the per-token read limits for your plan
- Set up the encrypted fallback file location, or the --no-file path, so no plain-text secrets are written to shared disks
- Test each export in a non-production target and check key counts and values against the source before cutover
How we hand over
- Deliver the export runbook, the transformer and format choices used per config, and a record of each verified transfer
- Document how exported files are stored, who can read them, and when they are securely deleted
- Provide a checklist for confirming dynamic secret leases have expired and that no exported copies remain on workstations or CI runners
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer after the export and the target platform go live
- Re-run exports for late changes in Doppler during the cutover window under the agreed scope
- Review the target platform's configuration and access rules as part of periodic retainer work

