How to export your data from Typeform

How do you export your data from Typeform before the contract ends?

Typeform's Responses API returns a form's responses as JSON on each GET request and can filter them by submission date, so you can pull the full history into storage you control before the contract ends. Plan for a lag of roughly 30 minutes: the API may not include the most recent submissions, so the final pull must run after the last form submission has been received and not at the same moment you switch off the form. This applies whether you are facing a renewal, a plan change, a data residency requirement, or a move to self-hosted Formbricks or LimeSurvey. Check the current behavior in the Typeform Responses API documentation before you script the export.

Response data is the part that exports cleanly. Uploaded files need their own download calls, so confirm the file endpoints and any authentication they need in the developer documentation, then test them on one form with a file question before you rely on them for the full set. Form design does not export. Question wording, branching logic, hidden fields, embed code on your websites and webhooks pointing at Typeform-connected tools all need to be rebuilt or repointed in the new platform. Record every hidden field and webhook destination now, because these are the items most often forgotten and they determine whether new submissions keep flowing into your systems after the switch.

The export only protects your data if the cut-over date is set in advance. Choose a freeze date, stop editing the Typeform forms, and keep the old form live until the new one has been tested end to end. Run a first bulk export, then a final incremental pull after the 30-minute window, and compare response counts per form between Typeform and the new instance. Ask Typeform, in writing, how long responses and files remain available after your plan ends, and keep the account active until your checksums match. A reader on a small plan, such as the one with 100 responses per month, should also confirm whether a quota pause could block submissions during the overlap period.

What the Typeform Responses API exports and how to filter it

This table shows which parts of a Typeform account can be pulled out programmatically, the format and filters each method offers, and the limits to plan around. Read it as a checklist before you set a cut-over date, because responses from the last half hour may be missing from any single pull.

Data type	Export method	Format	Limits and things to confirm
Form responses	GET request to the Responses API for a given form	JSON returned on each request	Can filter by submission date. Recent submissions, roughly the last 30 minutes, may not appear yet, so re-run the export with an overlapping window.
Form identifiers	Form ID and the account access token used in the request	Strings copied from the Typeform account	Confirm in the developer documentation how to find the form ID and how to create a token with the right scope for responses.
Uploaded files	File download endpoints in the Typeform developer documentation	Files retrieved as separate downloads, linked from responses	Confirm current endpoint paths, authentication and how file URLs behave (expiry, redirects) before you script the download.
Date-range pagination	Repeated requests using the submission date filter	JSON pages, combined into one archive	Confirm the page size and pagination parameters in the developer documentation, and keep a record of the last submission time pulled.
Access by plan	API and token availability depends on the account plan and settings	Not applicable	Confirm in the developer documentation and your account. Response limits per month on Basic, Plus, Business and Enterprise come from the pricing page and do not change the export method.

Export sequence: from freeze date to verified archive

This sequence moves every Typeform response and uploaded file into an archive you control, with counts checked form by form and window by window before anyone switches off the old system. It is designed so that submissions arriving during the export are caught by a final pull rather than lost.

Inventory every form and its identifier
Before any export runs, the form owner lists each Typeform form in the workspace, including drafts, closed forms and forms that feed embeds, webhooks or integrations. For each one, record the form ID, the public URL, the response count shown in the Typeform dashboard, and the owner who can answer questions about it. Keep this inventory as the master checklist, because every later count is checked against it. The step is done when every form has a row and nobody on the team knows of a form missing from the list.
Set a freeze date and stop intake
The team agrees a freeze date and time, and the form owner closes or redirects each form that still feeds the old system so no new submissions arrive after it. Update any embeds, links, and automations that point to those forms, and record the freeze time in the inventory. Confirm in the dashboard that each form is closed or redirected, and note the timestamp so that the final pull has a clear boundary. Submissions made before the freeze must be collected, while anything later is handled by the cut-over plan.
Run the full historical pull in date windows
Using the Responses API, the engineer requests each form's responses as JSON with submission date filters applied in consecutive windows, rather than as one large request. Save the raw JSON for each window with its form ID and date range in the file name, and log the number of responses returned and the pagination details. The output is one archive folder per form, containing the window files and a manifest of counts. Check that the windows meet end to end with no gaps or overlaps at the boundaries, because a missed boundary is the most common way responses disappear.
Repeat the final pull after the lag window
The Responses API may not return submissions from roughly the last 30 minutes, so the engineer waits until that period has passed after the freeze time and runs a second pull covering the freeze window. Store these results as a separate delta file and merge them by response token, keeping only responses not already in the archive. The step closes when the delta covers the period from the last historical window to the freeze time and the merged count matches the expected total from the dashboard. Do not skip this pull, since submissions made just before the freeze are the ones most likely to be missing from the first run.
Download uploaded files and match them to tokens
The engineer retrieves each uploaded file through the file download endpoints for the responses that contain file answers, saving every file under its response token and question ID so that it can be traced back to the submission. Record the file name, size, and, where the team can generate them, a checksum for each file at download time. Compare the number of file answers in the response JSON with the number of files saved, and investigate any mismatch before continuing. Confirm with the vendor or in your own tests how the endpoints handle very large files and expired links.
Verify counts per form and date window
The reviewer compares the archived response counts for each form, and for each date window, against the figures shown in the Typeform dashboard and the inventory taken at the start. Any difference is traced to a specific window or boundary and resolved by rerunning that window, not by estimating. The reviewer also checks that the file counts match the file answers found in the JSON. The step is done when every form and window reconciles, and the signed-off manifest is stored with the archive.
Store the archive and sign off the cut-over
The verified archive is copied to the target storage location under the organization's own control, with access restricted to the named owners and the manifest, counts and checksums kept alongside the data. The form owner and the security or compliance lead review the manifest and approve the cut-over in writing, which records the freeze time, the final pull time and the archive location. Only after this sign-off should the Typeform subscriptions, webhooks and integrations be retired. Confirm your retention obligations with your compliance team before deleting anything from the source account.

What does not carry over from Typeform and how to handle each gap

The Responses API returns submissions, not the form itself. Everything that defines how a form looks, behaves and connects to other systems has to be captured or rebuilt separately before the freeze. The cards below cover each gap, the workaround for it, and what to confirm with Typeform's documentation before you switch off the old forms.

Form design and layout

Page order, question grouping, media, colors and fonts are part of the form definition, not part of the response data. A JSON export of responses carries answers keyed to question IDs, but not the visual structure that respondents saw. Record each screen in a spec that lists question IDs, labels, required flags and choice values, so the rebuilt form in the target platform matches the answers you are archiving. Confirm with Typeform's developer documentation which form-level objects are readable through the API before deciding how much to capture by hand.

Conditional logic and hidden fields

Logic jumps and hidden fields decide which questions a respondent sees and what values get passed into the form. Answers exported from Typeform show what was submitted, but not the rules that produced the path. Write each jump as a structured rule, for example "if Q3 equals No, skip to Q7", and note every hidden field name and the source that populates it, such as a URL parameter. Test the rebuilt logic with the same paths used in production so that archived and new responses can be compared. Confirm how hidden field values appear in the Responses API output before the freeze.

Themes and branding

Themes, logos, custom domains and color settings belong to the account and do not travel with responses. Respondents who see a changed look may trust the form less, so capture the theme settings as a screenshot or export if Typeform provides one for your plan, and map each element to the target's theme options. Check whether the target edition can remove its own badge or apply a custom logo, since some branding options sit behind an Enterprise license. Confirm with the target's license documentation which branding features your edition includes.

Embeds and links pointing at Typeform URLs

Every website embed, short link, QR code, email invitation and printed handout that points to a Typeform URL will stop collecting responses when the old form is closed. Build an inventory of where each form is published, including the pages of your own site and third-party tools, before you set the cut-over date. Plan redirects from the old URLs to the new survey, and confirm with Typeform whether closed forms or their links can redirect or display a message. Update embed code only after the new survey is tested on each page.

Webhook configuration

Typeform webhooks push new submissions to a receiving endpoint, and they are configured on the form, not in the response export. Once the form is retired, any system that depends on those pushes will stop receiving data unless the same endpoint is connected to the new platform. Record each webhook URL, its trigger, and the consuming system before the freeze, then configure the equivalent webhook in the target and run both in parallel for a short period. Confirm with Typeform's documentation how webhook deliveries behave for submissions received during the switch.

Respondent accounts and workspace settings

Workspace members, roles, shared folders, and any settings that control who can view or edit a form are account-level configuration. The Responses API does not export them, and the target platform will need its own user accounts, roles and access rules. List every person with access to each form and the level they hold, then decide who needs access in the target and at what role. Confirm with the target's license documentation which roles and single sign-on options are included in your edition, because some access controls require an Enterprise license.

Shape the export for the target platform before you pull data

The self-hosted Formbricks Community Edition has no response cap, and it includes full API access and file upload. That means the Typeform archive can land in full, with each form mapped to a survey record and each submission mapped to a response record. Two decisions need to be made first because they shape the import: how many workspaces you need, and whether any Enterprise features are required.

Workspace layout: The Community Edition is limited to one workspace. If your Typeform accounts or teams map to separate groups, decide whether to merge them into one workspace or license the Enterprise key before the first import.
Survey records: Rebuild each Typeform form as a survey and keep the Typeform field references in your mapping file so every response row can be matched to its question.
Response records: Use the API access included in Community to write responses, and test the load against the release you will deploy, such as the 6.0.2 release published October 1, 2026.
Enterprise needs: Confirm whether you need OIDC or SAML single sign-on, teams and access roles, or audit logs. These require the Enterprise license key, and the enterprise code ships in the Docker images.
Uploaded files: File upload is part of Community, so plan the storage path for archived files and confirm the attachments are linked to the correct responses.

Confirm the workspace count and the Enterprise feature list with your security and administration owners before you run the first import.

What to plan before the Typeform renewal or termination

A Typeform exit is mostly a scheduling problem. The contract end, the response lag in the Responses API, and the time needed to rebuild forms all have to line up before anything is switched off. The cards below cover the decisions to make early and the records to keep once the move is finished.

Confirm the contract end and notice

Check your Typeform agreement for the end date, renewal terms and any notice period before you plan anything else. The notice window sets how long you have to finish exports while still paying for access. Ask your account owner to confirm these terms in writing, because the public pricing page does not describe them. Record who in your organization can approve the cancellation.

Set the freeze and final pull

Choose a freeze date after which the public forms stop accepting new submissions, or redirect them to the new survey. Because the Responses API may not include submissions from roughly the last 30 minutes, run a final pull after that lag has passed so the last responses are captured. Note the exact timestamp of the freeze in your cut-over record.

Keep Typeform open for verification

Keep the Typeform account reachable after the final pull until you have compared record counts and sampled uploaded files in the archive. Verification often finds gaps in date filters or pagination, and those are cheaper to fix while the source still exists. Agree with the account owner how long read access will remain, and confirm that it does not lapse on the same day as the contract.

Budget time for scripts and rebuilds

The export script, the form rebuild and the webhook or embed changes are internal work that a subscription does not cover. Assign an owner for the script, a reviewer for the rebuilt logic and hidden fields, and a person to update every page that embeds a Typeform. Estimate these hours with your team or your implementation partner before the freeze date, not after.

Check plan limits during the parallel run

While old and new forms run side by side, confirm which Typeform limits still apply: monthly responses on your current plan and the number of seats. A plan that is close to its response limit can start rejecting or charging for submissions just before the freeze. Confirm the limits with Typeform directly and check whether any upgrade is needed to keep the old forms live.

Retain the archive and verification record

Store the final export in a location you control, with checksums, the export script version and the freeze timestamp. Keep a written record of the verification results, including response counts per form and any exceptions, so auditors or internal reviewers can trace where each response came from. Set a retention period with your legal or compliance team, since it is not defined by the export itself.

How the 30-minute lag shapes the cut-over date

The Responses API does not guarantee that a pull returns every submission. Typeform's developer documentation notes that the endpoint may not include responses from roughly the last 30 minutes, so a single export taken at the moment you switch off the old form can miss the newest submissions. Those are exactly the responses people send while a cut-over is underway, and they are easy to lose because nothing in the output signals that they are missing. Plan the cut-over around that window rather than around the time you press export. A workable sequence starts with stopping new intake on the old form. Either close the form in Typeform or redirect its public link and any embeds to a holding page, then record the time you did it. Wait well beyond the lag window before the final pull, and then run a date-filtered request against the Responses API using the since and until parameters, covering from your previous full export to the freeze time. Compare the response count and the newest submitted_at value in the export with the totals you see in the Typeform interface for the same period. Confirm the exact lag behavior, the parameter names and how time zones are applied in the Typeform developers: Responses API reference before you fix any timing in your runbook. Keep the old forms open in read-only state until the new instance has passed verification, and do not delete anything on the Typeform side yet. Responses that arrive late, webhook retries and corrections can still land after the freeze, so a second short reconciliation a few days later is a sensible check. Only retire the Typeform forms once both counts match, the uploaded files have been confirmed in your own storage, and the sign-off owner has accepted the reconciliation in writing.

Questions teams ask before exporting from Typeform

How much effort does exporting responses from Typeform take?

The effort depends mainly on response volume, the number of forms, how many files were uploaded, and how much logic has to be rebuilt in the new tool. Pulling JSON from the Responses API is a bounded task for one form with a few thousand submissions, while a workspace with many forms, long histories and file-heavy surveys takes more scripting, checking and time. Ask for the response count per form and the number of uploaded files before you plan, because those two numbers shape most of the work.

Can our team export Typeform data alone using the Responses API?

Yes, a team with someone comfortable with HTTP requests and JSON can do it using the Typeform developer documentation for the Responses API. The GET request returns a form's responses as JSON, and it can be filtered by submission date, so exports can be done in date ranges. Plan for the fact that submissions from roughly the last 30 minutes may not appear, so the final pull should happen after a short pause in new submissions. Teams without scripting experience usually need a named engineer for this work.

What does our team need in place before starting the export?

You need API access to the Typeform account with a token that can read the forms you plan to export, a staging store where the raw JSON can be kept and checked, and a named owner who signs off that record counts match. The staging store should be access-controlled because responses often contain personal data. Keep the Typeform account active until verification is complete, since the export depends on it.

Are uploaded files included in a Typeform export, and how do we confirm it?

Uploaded files are not part of the response JSON itself, so they need their own handling through the file download endpoints described in the Typeform developer documentation. Build a list of file references from the responses, download each file, and store it alongside the matching response identifier. To confirm completeness, compare the number of downloaded files with the number of file-upload answers in the staged responses, and sample several files by opening them. Ask the owner to record any failed downloads so they can be retried.

Can we move historical Typeform data before the contract ends?

Yes, historical responses can be exported ahead of the contract end date, and most teams do this in a first pass that covers everything up to a cut-over date. A second, smaller pass then picks up submissions made after that date, using the date filter on the Responses API and allowing for the roughly 30-minute lag. Check the Typeform pricing page and your own contract for what happens to data after a subscription lapses, because that determines how much time you have. Confirm the retention terms in writing with Typeform.

How do we plan a cut-over date so no submissions are lost?

Choose a cut-over date, keep the old form live until the new one is verified, and run a final delta export that covers the window between the first pass and the switch. Pause or redirect embeds only after the delta export is complete and the lag window has passed. Compare response counts per form before and after, and keep the old form open for a short overlap period so late submissions are captured. Written sign-off from the named owner closes the process.

What would a fixed-scope DeployOpen engagement cover in writing before work starts?

DeployOpen's engagements are fixed-scope, so the written scope sets out which forms, response ranges and file sets are covered, the export method, the staging and access controls, the verification steps and the deliverables. It also lists the cut-over approach, what the client must provide, and the timelines agreed before work begins. Ask for the written scope to name who signs off each stage and how exported data is handed over and deleted from staging. Quotes follow from that scope, and DeployOpen does not publish a price list.

How DeployOpen scopes and delivers a Typeform data exit

DeployOpen approaches a Typeform data export as a fixed-scope engagement inside your own infrastructure, agreed in writing before work starts. We plan the export so responses and uploaded files are pulled, verified and archived on your servers before any form is switched off.

How we scope

Inventory every Typeform form, workspace and response set you need to keep, with owners named for each.
Agree in writing which date ranges, hidden fields, answer types and uploaded files the export must cover.
Set a cut-over window that accounts for the Responses API lag of roughly 30 minutes before the final pull.

How we build

Write export scripts against the Responses API that page through submissions using date filters and save raw JSON.
Download uploaded files through the file endpoints and store them with a manifest linking each file to its response.
Check record counts and checksums against Typeform totals, then test the archive on a restored copy in your environment.

How we hand over

Deliver the export archive, scripts, manifest and a reconciliation report showing what was retrieved and what was excluded.
Document the cut-over runbook, including the final sync, the switch of embeds and webhooks, and rollback steps.
Record retention locations and access controls so auditors and records owners can trace every response afterward.

How we support

Engagements are fixed-scope, and ongoing support, upgrades and continuous testing are available as a retainer.
Support can cover re-running the final sync if late submissions arrive after the planned cut-over date.
Ask us to confirm the scope, deliverables and timeline in writing before you commit to a Typeform exit date.