What you can export from CircleCI and what you cannot
Pipeline configuration leaves with every repository clone, and environment variable values do not leave at all. Artifacts can be pulled out through the API, but only while they still exist, since CircleCI keeps them for at most 30 days. If your exit is driven by a renewal, a pricing change or a data residency requirement, plan the move around those two limits first, because they set the deadline and decide which values you must re-create rather than copy.
The configuration is the easy part. CircleCI pipelines are defined in a config file kept in the project repository, so any clone of that repository carries the pipeline definition with it. Check each project for config that is generated, pulled in from shared orbs, or driven by settings in the CircleCI interface, such as contexts and project-level options, because those do not sit in Git and must be written down by hand. Ask your team to inventory every project, including dormant ones, before the export starts.
Build artifacts are different because they expire. The artifacts documentation describes listing a job's files through the API v2 endpoint /api/v2/project/:vcs/:org/:project/{job_number}/artifacts with a Circle-Token header, then downloading each returned file. Individual files can be up to 3 GB, so script the download and verify checksums. Environment variables are a harder case: the CircleCI docs state that values cannot be read in the web app after they are set. Your source of truth for those values is the original secret store, or you rotate each credential and re-create it in the new system. Treat that rotation as part of the migration, not an optional cleanup.
Which CircleCI data can be exported, by method, format and limit
This table compares each category of CircleCI data by the export method, format and limit that applies to it. Read it before planning a move, because some data is already in your repositories, some must be downloaded within a fixed window and some values cannot be read back at all.
| Data type | How to export | Format and limit |
|---|---|---|
| Pipeline configuration | Already stored in each repository as the CircleCI configuration file, so any clone of the repository carries it | YAML configuration file in the project repository; no export step required |
| Build artifacts | List a job's artifacts with the API v2 artifacts endpoint, sending a Circle-Token header, then download each file from the returned URLs | Original files; kept 30 days by default and at most 30 days; each file limited to 3 GB |
| Artifact retention window | Start the download before the 30-day window closes, because later builds cannot recover expired files | Retention set to 30 days as both default and maximum; confirm your project setting in CircleCI |
| Environment variable values | Cannot be read in the web app after they are set; take values from the original secret store | Not exportable from CircleCI; values must be re-created or rotated in the new system |
| Project metadata and settings | Review in your own CircleCI account (projects, contexts, and their settings) and record them manually or through the account's own views | Confirm exact fields and any export options with CircleCI support before relying on them |
| Secrets and tokens | Rotate every credential the pipelines used, including API tokens, deploy keys and cloud keys | Rotation must be planned for the move regardless of export; CircleCI told customers to rotate secrets after its January 2023 incident |
What does not leave CircleCI and the workarounds
Some CircleCI data can be copied out with the API and the repository, and some cannot. Environment variable values and expired artifacts are the two gaps that change migration planning. Each card names the gap, the workaround and what to verify before cutover.
Environment variable values
CircleCI does not show environment variable values in the web app after they are set, so a migration cannot copy them out of the platform. Treat the original secret store as the source of truth. Where that store exists, pull values from it. Where it does not, plan to rotate each credential and create it again in the new CI system. Confirm the list of variables and their owners before cutover.
Secrets that need rotation
A move gives a chance to rotate deployment keys, cloud credentials, tokens and signing keys that CI held. CircleCI told its customers to rotate secrets after its January 4, 2023 incident, which shows that hosted CI stores can be exposed. Rotate in the new system first, then revoke the old credential after the last CircleCI build has finished. Record which service each secret belongs to so no deployment breaks silently.
Artifacts past the retention window
CircleCI keeps artifacts for at most 30 days, and that limit is both the default and the maximum. Artifacts older than that are gone from CircleCI, and no supplied export path restores them. Download the artifacts you need through the API v2 artifacts endpoint before the window closes, and keep release binaries in your own registry or object store.
Regenerating expired artifacts
For artifacts that have expired, the practical workaround is to re-run the build at the same commit in the new CI system and produce the files again. This works only when the source, dependency versions and build inputs are still available and the build is reproducible. Confirm with the owning team that a rebuild gives an equivalent output, and note any artifact that cannot be reproduced for audit records.
Pipeline configuration
Pipeline definitions are not a gap. The CircleCI configuration file lives in each project repository, so any clone of the repository carries it. Check, however, that the file depends on nothing outside the repository, such as contexts, orbs or project settings that exist only in the CircleCI UI. Those settings must be documented separately before the move.
The export sequence and how to verify each step
This sequence separates what can be copied out of CircleCI from what cannot, so that each class of data has a known destination and a check that it arrived. Run it before any cutover, while the CircleCI project and its build history are still available.
Inventory every repository and its CircleCI config
The platform team lists each repository connected to CircleCI, including forks, monorepo subdirectories and archived projects, and records the path of its CircleCI configuration file. Because pipelines are defined in that file in the project repository, a clone already holds the pipeline definitions. Confirm that the configuration file exists on the default branch of every clone and on each long-lived release branch that still builds. The output is a spreadsheet with one row per repository, its config path, its default branch and the owner who will sign off the migration of that row. A repository without a config file on its default branch is a question to resolve with the owner, not an assumption to skip.
Export recent build artifacts through the API
Before the retention window closes, the team lists each job's artifacts through the CircleCI API v2 endpoint for artifacts, authenticated with a Circle-Token header, and downloads each file from the URLs returned. CircleCI keeps artifacts for at most 30 days and limits single files to 3 GB, so jobs older than the window are already gone and cannot be recovered. Work from the newest builds backward, and keep a log of job numbers, file paths and checksums. The check is a count comparison: the number of files returned by the listing for each job must match the number of files on disk, and each checksum must match the value computed at download. Any mismatch is re-downloaded before the job is marked complete.
Export build history and test results you need to keep
Artifacts are not the only record a team may need. The team decides which build logs, test reports and deployment references must survive the move, then saves them in a format that stays readable without CircleCI, such as plain text logs and JUnit XML files. This step is owned by the engineering lead with input from compliance, because retention obligations differ by organization. The check is a sample review: pick a few builds from each project, open the exported copy and confirm that the commit SHA, job name, timestamp and pass or fail result are all visible. Record in the migration file where the archive is stored and who can access it.
Record every environment variable and its origin
CircleCI states that environment variable values cannot be read in the web app after they are set, so the platform team cannot copy them from the interface. Instead, list each variable name, the project or context it belongs to, and the system that holds its true value, such as a cloud secret manager, a vault or a password manager. Where no original source exists, mark the variable as needing rotation. Mapping the names this way shows which values can be re-entered from their source and which must be re-created. The check is a reconciliation: the count of names in the inventory must equal the count of names in the CircleCI project and context settings, and every row must name an origin or a rotation owner.
Rotate the secrets that cannot be recovered
Secrets with no retrievable source should be rotated at the issuing system, such as the cloud provider, the registry or the SaaS vendor, and the new values stored in the destination CI system's secret store. CircleCI's January 4, 2023 incident report told all customers to rotate secrets after an attacker exfiltrated environment variables, tokens and keys, so the move is a natural point to rotate everything that CircleCI held, not only what was lost. Rotate in a planned order, deploy-time credentials first, and confirm each new value works in a test pipeline before the old one is revoked. The check is a test run per secret that uses the new value and succeeds, followed by a record of the revocation date for the old credential.
Confirm the copies in a separate location
Store the artifact archive, config files, build history and variable inventory in a location that does not depend on CircleCI, and have a second person verify them. The verifier opens a random sample of artifacts, confirms that checksums still match, and checks that each config file in the archive matches the file on the default branch of its repository. This is the step where gaps surface, so the verifier should be someone other than the person who performed the export. The output is a signed-off migration record that lists what was exported, what was rotated, what was dropped on purpose and the reason for each exception. Keep this record with the cutover plan so auditors and future maintainers can trace each decision.
Why secret rotation belongs in every CircleCI exit plan
Plan secret rotation before the first pipeline runs on the new system, because the CircleCI environment variables that hold deployment credentials cannot be read back out of the app. On January 4, 2023, CircleCI told all customers to rotate secrets after an attacker exfiltrated customer environment variables, tokens and keys, along with the encryption keys needed to read them. The lesson for an exit is that a hosted CI service holds the keys to every connected deployment target, so the credentials behind each variable should be treated as already exposed until they are replaced. The CircleCI incident report is the starting point for reviewing what the company said customers should do.
Build the rotation into the migration as a workstream with its own inventory. For each variable, record which pipeline and which deployment target uses it, who owns the credential at the source (cloud account, registry, database, signing key or third-party API token), and where the replacement will be stored on the new system, such as a secrets store, Woodpecker CI secrets or Jenkins credentials. Because CircleCI will not show the values, the owner usually has to generate a new credential at the source rather than copy the old one. Confirm with each owner which values can be regenerated without downtime and which need a maintenance window.
Revocation is the step teams most often skip. Once the new CI system deploys successfully, disable or delete the old credentials at their source and remove the CircleCI project, context and token from each service account. Keep the old credentials valid only for the parallel-run period you agreed, and log the date each one was revoked so an auditor can match the change to the record. Also rotate the CircleCI API tokens used for artifact downloads and any personal access tokens that could still reach the old project, and check that no webhook or deploy key still points back to CircleCI.
Export paths by team situation
Teams that keep GitHub, GitLab, Gitea, Forgejo or Bitbucket as their source host move only the build engine. The repositories stay where they are, and the pipeline definitions already live in them, so most of the configuration travels with every clone. Secrets and artifacts are the parts that need deliberate work.
- Moves easily: The CircleCI configuration file in each repository. Woodpecker reads YAML workflows from
.woodpecker.yamlor a.woodpecker/directory, and Jenkins reads aJenkinsfilefrom source control. - Needs rotation: Environment variables and contexts. CircleCI does not display values after they are set, so copy them only from the original secret store, then re-create and rotate them in Woodpecker or Jenkins credentials. Forge webhook tokens and deploy keys belong on the same list.
- Needs a rebuild: Orbs and executors. Orbs map to Woodpecker plugins or to Jenkins plugins and shared libraries, and Docker executors map to container steps in Woodpecker or to Kubernetes pod agents in Jenkins.
- Needs an API export: Artifacts from the last 30 days. List them with the API v2 artifacts endpoint, authenticate with a
Circle-Tokenheader and download each file, noting the 3 GB per-file limit. - Needs a check: Jenkins backups. All configuration, plugins and secrets live in
$JENKINS_HOMEon the controller, so back up that directory with the same care as the secrets you re-created.
Confirm which forge events your Woodpecker server supports and whether your deployment targets accept rotated credentials before you schedule cutover.
Teams moving to GitLab CI/CD also move repositories into GitLab, so the export has two paths: source and history through GitLab's import tooling, and CI data through CircleCI's own interfaces. The pipeline logic has to be rewritten into .gitlab-ci.yml, and GitLab's import documentation should be checked against your version to confirm which project items it carries before you rely on it.
- Moves through import: Repository code and branches. Confirm with the GitLab import documentation whether issues, merge requests and pipeline history come with the project.
- Needs translation: The CircleCI configuration file. Each workflow, job and executor becomes a stage or job in
.gitlab-ci.yml, and this step is manual work for most pipelines. - Needs rotation: Every CircleCI environment variable. GitLab CI/CD variables are entered again, so treat each value as a secret to rotate, because the old values cannot be read from CircleCI.
- Needs a rebuild: Runners. GitLab Runner replaces CircleCI runners, and you choose the executor for each job, so plan capacity and network access before cutover.
- Needs a tier decision: Feature scope. GitLab's pricing page lists advanced CI/CD in Premium and security and compliance features in Ultimate, so confirm which tier covers the CI features you depend on.
Ask GitLab which import items your version supports and export artifacts from CircleCI within the 30-day window before the source repositories are switched.
Teams already running CircleCI Server inside their own network keep CI data in their cluster. The export question shifts from what leaves a vendor to what leaves the cluster, and to what your administrators can still reach. The configuration and artifact steps are the same, but the secret keys, storage locations and retention settings have to be confirmed inside your own installation.
- Moves easily: The configuration files in repositories. They travel with clones, whether the pipelines ran on hosted CircleCI or on Server.
- Confirm first: Artifact retention and storage. The 30-day limit applies to CircleCI's documented artifact storage, so ask your Server administrators which retention setting and storage backend apply to your installation before the window closes.
- Needs rotation: Environment variables. Values cannot be read in the app, and the January 4, 2023 incident report showed that encryption keys are needed to read stored secrets, so find out who holds those keys and rotate values after the move.
- Needs a rebuild: Infrastructure. Server's stack of Kubernetes, Nomad, MongoDB, PostgreSQL, RabbitMQ, Redis and Vault is not carried into Woodpecker, Jenkins or GitLab, so each engine needs its own database, agents and backups.
- Needs offline planning: Installers and plugins. Woodpecker, Jenkins and GitLab each need packages, images and plugins mirrored inside the network, and GitLab documents offline installation separately.
Ask your Server administrators for an inventory of secrets, artifact storage and key locations before you commit to a cutover date.
Questions teams ask before exporting from CircleCI
How much effort does exporting from CircleCI take?
The effort depends mainly on how many projects you run, how much artifact data your builds keep, and how many environment variables and contexts hold live secrets. Pipeline configuration is the easy part, because the CircleCI configuration file lives in each repository and leaves with any clone. Artifacts need a scripted download through the API, and secret values need a separate inventory. Teams with a few projects and few secrets usually face a small task, while large estate with many contexts needs a plan for ownership and rotation. Ask any partner to break the work into those components in a written scope.
How long does a CircleCI export take?
Duration is driven by the same factors as effort: project count, artifact volume, the number of variables and contexts, and how many people must confirm secret ownership before anything is rotated. Artifact downloads are limited by the amount of data and the API calls needed to list each job's files, so a build history with many large files takes longer. Secret rotation is often the slowest step because it depends on other teams updating credentials in their own systems. Ask for a timeline that shows each phase separately, and confirm it against your own environment before committing.
What access and credentials does the team need to provide?
Plan to provide four things before work starts:
- Read access to every repository that holds a CircleCI configuration file.
- A CircleCI API token with permission to read the projects you want to export, sent as a Circle-Token header.
- Named owners for each environment variable, context and connected service account.
- Access to the original secret stores, such as a password vault or cloud key manager, where the real values live.
Secret values cannot be read back from CircleCI's web app, so the owners and their source systems are what make rotation possible.
Can we run the CircleCI export in-house?
Yes, a team with CircleCI administrator rights and engineers comfortable with the REST API can script the artifact download and inventory the configuration files. The harder work is governance: deciding which secrets are still valid, who approves each rotation, and how the new CI system receives values without exposing them in chat or tickets. Teams that lack spare capacity during a renewal window often bring in an implementation partner under a fixed-scope agreement. Whichever route you choose, keep the export logs and the rotation record as evidence for later audits.
Can artifacts be recovered after the 30-day window closes?
No. CircleCI keeps artifacts for at most 30 days, which is both the default and the maximum storage duration, and no supplied source describes a recovery route after that period. Any artifact you need for audit, release traceability or rollback must be downloaded while it still exists. Start with the build numbers that matter most, such as production releases, and check whether those artifacts can be rebuilt from source. Confirm your own retention needs with your compliance owner before the window closes.
Which CircleCI items can be exported directly, and which cannot?
Pipeline definitions can be exported directly because they sit in the repository as a CircleCI configuration file. Build artifacts can be exported through the API while they are still retained. Environment variable values cannot be exported, since CircleCI states they are not readable in its app after they are set. Those values must come from your original secret store or be rotated and created again in the new CI system. Treat the secret inventory as its own workstream, and do not assume the old platform will reveal it.
Why should the secret rotation happen as part of the move?
Hosted CI services hold deployment secrets for every connected project, and CircleCI told customers in its January 4, 2023 incident report to rotate secrets after an attacker exfiltrated environment variables, tokens and keys together with the encryption keys needed to read them. Because values cannot be copied out cleanly, rotating them during the move gives you a known set of new credentials and closes the old exposure. Schedule rotation with each service owner, update consuming systems in the same change window, and revoke the old values once the new pipelines have passed their checks.
What to plan before the CircleCI contract renews or ends
The items below set the order of work before a renewal date or contract end. Several depend on the 30-day artifact window, and most depend on facts that only CircleCI and your own contract can confirm, so check each one early.
Start artifact exports early
CircleCI keeps artifacts for at most 30 days, and that is both the default and the maximum. Start the export well inside that window, because a job that finished last week may already be close to expiry. Script the listing and download through the v2 artifacts endpoint, run it on a schedule, and keep a record of which job numbers were exported. Anything not downloaded before the window closes cannot be recovered from CircleCI.
Inventory every project and context
Build a list of every CircleCI project, its repository, its branches that run pipelines, its scheduled triggers, and every context that projects reference. Note which contexts hold deployment credentials and which projects use them. The list becomes the migration backlog and tells you which pipelines a missing secret would break. Pipeline definitions are safe in each repository, but the inventory is what shows you what the repositories alone do not contain.
Confirm billing and credit usage
Ask CircleCI for your current credit consumption by project and by month, and for the exact date your term ends or renews. Check whether notice periods apply to non-renewal and whether any unused credits or overage charges carry into a final invoice. Your contract, order form or account team is the source for these terms, so do not rely on public pricing pages or on what a colleague recalls.
Check data retention terms in the contract
Read your agreement for any clause on data return, deletion and retention after termination, including how long CircleCI keeps logs, build data and backups. Ask in writing whether any export tooling or assisted export is available and on what timeline. Treat the 30-day artifact window as the documented default, and confirm with CircleCI any other retention period you need to plan around before you rely on it.
Set a parallel-run period
Run the new CI system alongside CircleCI for a defined period before switching. Mirror a representative set of pipelines, including deployments to a non-production environment, and compare outputs, test results and artifacts. Decide in advance which pipelines must pass parallel runs before CircleCI is turned off, and keep CircleCI active until the last required pipeline has been proven on the new platform.
Agree the secret rotation schedule
CircleCI does not show environment variable values after they are set, so you cannot copy them out of the app. Recover values from the original secret store where they exist, or rotate and re-create each credential in the new system. Agree a schedule that rotates high-impact deployment keys and tokens first, and revoke the old ones after cutover. CircleCI's January 4, 2023 incident report told customers to rotate secrets, which is a reason to rotate on a planned schedule rather than in a rush.
How DeployOpen scopes and delivers a CircleCI data exit
DeployOpen plans and delivers a CircleCI data exit as a fixed-scope engagement, starting with a written inventory of what can leave CircleCI and what cannot. The work covers config files, retained artifacts, secret handover and the new CI system that receives them, with each step documented for your own team.
How we scope
- Inventory every CircleCI project, its config files, contexts and artifact retention window before work starts
- Agree in writing which pipelines, artifacts and build history are in and out of the export
- Identify which environment variables must come from your original secret store and which need rotation
How we build
- Script API v2 artifact downloads for each job number, storing files with job metadata and checksums
- Move pipeline configuration into the target engine's format and test it against recent commits
- Re-create secrets in the new system, rotate credentials and confirm that old CircleCI tokens are revoked
How we hand over
- Deliver a written runbook covering the export scripts, mapping decisions and each rotated secret
- Provide an evidence pack listing exported artifacts, verification results and open exceptions
- Walk your engineers through the new pipelines so they can maintain the configuration after handover
How we support
- Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts
- Ongoing support, upgrades and continuous testing of the new CI system are available as a retainer
- Ask for a quote based on the written scope, covering project count, artifact volume and secret count

