Migrate from Typeform to Formbricks: what the move involves
The move is mostly rebuilding surveys and logic in Formbricks, plus a scripted export of historical responses and uploaded files from Typeform. The effort depends on how many forms you run, how complex their logic and hidden fields are, and how many webhooks, embeds and downstream tools rely on them. Start by inventorying every Typeform form with its response volume, logic branches, hidden fields, file upload questions and integrations, because that list sets the scope for everyone involved. Typeform's conversational layout does not carry over one to one, so each form needs a decision about how it will appear as a Formbricks link survey, website survey or in-app survey.
In most organizations an internal platform or IT team does the rebuilding, export scripting and cutover, since they hold the Typeform account and know which systems consume the data. An implementation partner is useful for scoping the work, reviewing the export design, testing the new webhooks and planning the switchover date so that no submissions are lost during the overlap. Formbricks is licensed under AGPLv3 and can be self-hosted with Docker without a subscription, so the recurring cost of the Community Edition is the infrastructure and the people who run it. Ask any partner for a written scope that names the forms in and out of scope, the integrations to be re-pointed and who signs off on the cutover.
Before you commit, confirm the features your forms depend on against the Community Edition, which covers advanced logic, multi-language surveys, file upload, webhooks and full API access. Features such as OIDC and SAML SSO, teams and access roles, and removing the Powered by Formbricks badge require an Enterprise License Key, which is shipped in the Docker images and unlocked separately. Check the current Enterprise license documentation for the exact terms before budgeting, and confirm with your team whether any of these features are required for compliance or access control. Plan a parallel run so that Typeform keeps collecting until the Formbricks endpoints and exports are verified.
Which Typeform capabilities map cleanly to Formbricks
This table maps the Typeform features most likely to matter in a move against Formbricks Community Edition and the Enterprise license. Read the status column as a planning signal: clean means the feature exists in the free self-hosted edition, needs rework means it exists but behaves or is configured differently, and gap means it needs the Enterprise key or confirmation before cut-over.
| Typeform capability | Formbricks equivalent | Mapping status |
|---|---|---|
| Logic jumps | Advanced logic is included in the Community Edition | Clean. Test each jump path you rely on. |
| Multi-language forms | Multi-language surveys and UI are included in the Community Edition | Clean. Re-enter translations and check each language. |
| File upload questions | File upload is included, but files are stored on your own server | Needs rework. Confirm size limits and storage setup, then re-test uploads. |
| Hidden fields | Not covered by the supplied facts; confirm how pre-filled values are passed in links | Needs rework. Rebuild the pass-through in each survey link and test it. |
| Webhooks | Webhooks are included in the Community Edition | Needs rework. The payload differs, so update every receiving system. |
| Embeds and shareable links | Link, website and app surveys are included in the Community Edition | Clean. Replace embed codes on each site and confirm rendering. |
| Responses API and history | Full API access is included; Typeform's API may lag about 30 minutes | Needs rework. Export history first, then confirm the import method for your data. |
| Workspaces and team roles | One workspace in Community; teams and access roles need the Enterprise license | Gap for multiple teams unless you hold an Enterprise key. |
| SSO and HIPAA | OIDC and SAML SSO need the Enterprise license; HIPAA is not covered by the supplied facts | Gap. Confirm SSO licensing and any HIPAA controls with the vendor before use. |
What data and integrations move, and through which export path
A Typeform move has four parts: response data, uploaded files, form definitions and the integrations that consume them. Each one follows a different path, and only the first has a machine-readable export. Plan each path separately so nothing is lost at cut-over.
Historical responses via the Responses API
The Typeform Responses API returns a form's responses as JSON on each GET request and can filter by submission date. Pull the full history in date windows, store the raw JSON before transforming it, and keep the form ID and response token so records can be traced later. Because the API may not include submissions from roughly the last 30 minutes, the final export must run after the Typeform form is closed or pair a last-window pull with a short overlap. No import tooling is assumed, so the transform from Typeform JSON into Formbricks responses is custom work that your team or implementer must write and test against a sample export.
Uploaded files through download endpoints
File uploads are not part of the response JSON in the same form, so they need their own download step. Map each file answer to the response it belongs to, download the file, and store it on your own storage with a naming scheme that keeps the response ID in the path. Confirm file size limits and retention rules with Typeform before the move, and verify a sample of downloaded files open correctly before deleting anything in the source account. In Formbricks, file upload is available in the Community Edition, but confirm where it stores files in your self-hosted setup.
Rebuilding form definitions by hand
Typeform's question structure, logic jumps, hidden fields and thank-you screens are not exported as a ready-to-import Formbricks survey. Document each form's questions, branching rules and hidden fields in a spreadsheet, then rebuild them as Formbricks link surveys and test every logic path with the same answers used in Typeform. Hidden fields should be checked against the URL parameters your campaigns pass, since those values often feed CRM or analytics tools. Expect this to be the largest manual effort for forms with many branches.
Webhooks and response routing
Any webhook from Typeform that posts new responses to a CRM, data warehouse or ticketing system must be repointed to the Formbricks webhook endpoint on your instance. Formbricks payloads use their own structure, so the receiving system may need field mapping changes. Run both systems in parallel for a set period, compare record counts from each, and only then disable the Typeform webhook to avoid duplicate or missing records.
Embeds, links and Zapier or n8n flows
Websites, emails and QR codes that point to Typeform URLs or embed its widget must be replaced with Formbricks link surveys or embed snippets, and every published URL needs a redirect plan where possible. Zapier or n8n flows that trigger on Typeform responses need a new trigger connected to Formbricks, which is supported through its integrations. Inventory every place a form is referenced, including partner sites and printed materials, because those links are hard to change after publication.
The migration sequence from inventory to decommission
This sequence moves Typeform forms, responses and uploaded files to a self-hosted Formbricks instance without losing submissions. Each step ends with a written record that the next step depends on, so the cutover is a decision you can show an auditor rather than a hope.
Inventory forms, responses and integrations
The form owner and the platform or IT lead list every Typeform form, its live status, its question count, its logic and hidden fields, its embed locations, and every webhook, Zapier or other connected tool that receives its data. Add the response volume per form and where uploaded files are stored. The output is a form register with one owner per form and a list of every downstream system that must be repointed. The step is done when the register is signed off by each owner.
Build and approve a pilot survey
Deploy Formbricks on your own infrastructure, then rebuild one low-risk Typeform form as a link survey, including its branching, hidden fields and file upload questions. Test on desktop and mobile and confirm that responses reach the Formbricks responses view and any configured webhook. Check whether any feature in the form needs the Enterprise license, such as SSO-gated access or removal of the Powered by Formbricks badge, and record that decision. The output is a pilot sign-off from the form owner and the security reviewer.
Rebuild the remaining forms and wire integrations
Rebuild the rest of the register in the same way, recording each deviation from the original form, such as a question type that works differently or a logic rule that had to be simplified. Repoint webhooks and replace Typeform embeds with Formbricks link or website survey code. Confirm each integration with a test submission. The output is an updated register that marks each form as rebuilt, tested and integrated, with the deviations listed beside it.
Run both tools in parallel
Keep Typeform collecting while the new Formbricks forms collect the same data, and compare the two streams for a period agreed in advance by the form owners. Reconcile counts per form each day and investigate any gap, duplicate or field that differs. Confirm that respondents can reach the Formbricks surveys from every channel where they were previously sent. The output is a reconciliation log showing matching counts per form and a list of resolved discrepancies.
Export historical responses and files
Pull the historical responses from Typeform through the Responses API, filtering by submission date, and download uploaded files through the file download endpoints. Because the API may not include submissions from roughly the last 30 minutes, run the export after a short buffer and repeat a date-filtered pass to capture late submissions. Store the exports and files in your own archive with checksums and access controls. The output is an archive per form with a manifest listing record counts and file counts.
Cut over on a fixed date
On the agreed cutover date, stop new publishing in Typeform, disable its embeds and webhooks, and run a final date-filtered export to capture everything submitted up to the cutover point. Compare the final counts against the reconciliation log and confirm that each form's Formbricks endpoint is the only live collector. The output is a cutover record with the final export manifest, the time of the switch and the named approver.
Decommission the Typeform account
After the owners confirm that the archive is complete and readable, cancel the Typeform subscription and request deletion of the account data under the terms of the Typeform account, retaining the archive under your own retention policy. Revoke API tokens and remove the integrations. Ask Typeform to confirm in writing how it handles data deletion and any data kept after closure. The output is a decommission record with the archive location, the token revocation date and the vendor's written confirmation.
How the Typeform export and Formbricks rebuild fit together
The migration runs as two parallel tracks that meet at a cut-over date. The first track moves history out of Typeform: a script calls the Responses API, which returns a form's responses as JSON on each GET request and can filter by submission date, and writes the results, along with any uploaded files, into an archive your organization controls. The second track rebuilds each form in Formbricks as a link survey, recreating questions, advanced logic and hidden fields, so that new respondents land in the new instance. Typeform's API may not include submissions from roughly the last 30 minutes, so the archive pull should cover a window that ends before the cut-over and a second pull should sweep up the gap. Confirm the current lag and any file download limits in the Typeform developer documentation before you script it.
The self-hosted Formbricks instance should sit inside your own network boundary, in the cloud account, data center or private cluster where your other regulated systems run, with its database and file storage on infrastructure you administer. Place the archive store in the same jurisdiction so that respondent records and uploaded files are not copied elsewhere during the move. Plan one workspace for the Community Edition, because the self-hosted Community Edition is limited to one workspace. If your forms belong to several business units that need separate workspaces, decide before the rebuild whether they share one workspace or whether you need the Enterprise license. Also decide who owns the archive and who may query it, since Formbricks will hold only the responses collected after cut-over.
How the move differs by team size and starting point
A small team with a handful of forms and no SSO requirement usually has a short migration. Most of the effort is rebuilding a few questionnaires as link surveys in Formbricks and confirming that each one still collects the answers people need. The Community Edition covers this case without a license key, because it includes unlimited surveys, responses and users, advanced logic, file upload and multi-language surveys.
- Inventory first: List every live Typeform, its public link, its hidden fields and its embed locations so nothing is forgotten at cut-over.
- Rebuild in one workspace: The Community Edition allows one workspace, so place all surveys in it and plan naming conventions early.
- Export responses once: Pull historical responses through the Responses API, keeping in mind that recent submissions may be missing for about 30 minutes.
- Replace embeds at the end: Swap the Typeform embed or link on your site only after the Formbricks survey has been tested on desktop and mobile.
- Keep the old form closed, not deleted: Retain the Typeform account for a short period so late responses can still be retrieved.
Before starting, confirm that the single-workspace limit and the feature list match what the team actually uses.
A team with many forms that send responses into CRMs, ticketing tools or data stores has a migration driven by integrations rather than by question design. Each Typeform webhook or Zapier-style connection must be mapped to a Formbricks webhook, and the payload fields must match what downstream systems expect. Formbricks integrates with Slack, Notion, Zapier and n8n, and includes webhooks in the Community Edition, so the integration work is typically the largest part of the project.
- Map every webhook: Record the target URL, the trigger and the expected payload for each Typeform connection before rebuilding anything.
- Test payload parity: Send test responses to a staging endpoint and compare field names and types with what the receiving system already parses.
- Run both systems in parallel: Keep Typeform webhooks active while Formbricks webhooks are validated, then switch over form by form.
- Plan the file path: Uploaded files need their own transfer route, since downstream systems may store only links that point to Typeform.
- Confirm API access: The Community Edition includes full API access, so check that automations relying on specific endpoints can be reproduced.
Ask the integration owners to sign off on each switch-over date, because a single missed webhook can silently drop records.
A regulated team, such as a bank, healthcare provider or public body, usually needs SSO, role-based access, audit logs or removal of the Powered by Formbricks badge. Several of these are listed as Enterprise license features, so the scope must be decided before the build starts. Self-hosted Formbricks needs an Enterprise License Key for OIDC and SAML SSO, teams and access roles, audit logs, whitelabel email follow-ups and badge removal. The Enterprise code ships in the Docker images and is unlocked by that key, so the decision is about licensing, not about a separate download.
- List required controls: Write down which of SSO, roles, audit logs and branding removal are mandatory, and which are preferences.
- Decide on the key early: If any mandatory control is on the list, budget for an Enterprise License Key before the project starts.
- Check Typeform's gating: Compare the controls you need with Typeform's tier list, since SSO and HIPAA are tied to its Enterprise plan.
- Plan for AGPLv3 obligations: Privately kept forks must be released under AGPLv3 unless covered by an Enterprise license, so review any custom code with counsel.
- Document evidence: Keep configuration records and access reviews for the controls you rely on, and confirm with your auditor what evidence they expect.
Confirm the license terms and key scope in writing with Formbricks before committing to a timeline.
What usually goes wrong and how to prevent it
Most failed Typeform moves are not caused by the new platform. They come from timing, from assets that sit outside the form definition, and from assumptions about what the free edition includes. The cards below cover the failure points we see most often, each with a check to run before you switch respondents over.
Lost submissions during cutover
Typeform's Responses API can omit submissions from roughly the last 30 minutes, so a single export taken at the moment you close the old form will miss people who finished just before. Respondents who submit while the new survey is going live can also land in the gap. Prevent it by running a final export after the old form is closed, then a second filtered pull for the window between your first export and the switch, and comparing counts in both systems before you retire the old form.
Uploaded files left behind
Responses are JSON, but file upload answers point to separate Typeform-hosted files that do not travel with the response data. If you import only the answer text, every document, photo or signed attachment remains in Typeform and can disappear when the account is closed. Prevent it by listing every file upload question, downloading the files through their endpoints, and storing them in your own object store with a mapping from response ID to file name so each record can be matched later.
Broken embeds and webhook URLs
Websites, intranet pages, CRM automations and partner systems often reference the Typeform embed snippet or a webhook receiver that still expects the old payload shape. After the switch, those integrations may silently stop receiving data. Prevent it by inventorying every place the form is embedded or posted to, then configuring the Formbricks webhook and embed in staging and sending a test response to each receiver before changing any live page.
Logic that does not translate exactly
Typeform logic jumps, calculated fields and hidden fields are rebuilt by hand in Formbricks, and some conditions behave differently or need restructuring as separate questions. Small differences can route respondents to the wrong follow-up or drop a hidden value that a downstream system depends on. Prevent it by writing a test matrix of every branch and hidden field from the Typeform definition, then walking each path in the new survey and checking the stored values against the expected output.
Respondents hitting old links
Printed QR codes, email invitations, social posts and bookmarked links point to the old Typeform URL. Once the form is closed, those people see an error or a dead page, and response rates fall without any visible fault in the new system. Prevent it by keeping the old form in a closed state with a message that points to the new link for a period you set in advance, and by confirming with the owner of each distribution channel which link they are using.
Enterprise-only features assumed free
The Community Edition includes unlimited surveys, responses and users, but it is limited to one workspace. Features such as OIDC and SAML SSO, teams and access roles, audit logs and removal of the Powered by Formbricks badge need an Enterprise License Key. Prevent it by mapping each Typeform feature your team relies on, including SSO, team roles and branding, against the Formbricks license documentation before you commit to the Community Edition and get the Enterprise pricing in writing if any of them are required.
What drives the cost and duration of the migration
This table lists the components that set the cost and effort of moving from Typeform to self-hosted Formbricks, who is paid for each one, and whether it is one-time or recurring. Use it to scope a quote and to see which items you can reduce yourself. The main takeaway is that the largest variable is usually the rebuild and cutover work, not the software licence.
| Driver | Why it changes cost or effort | How to keep it down |
|---|---|---|
| Number of forms and questions | Each form is rebuilt by hand as a link survey, so effort grows with form count and question count. Typeform has no one-click export into Formbricks. | Retire unused forms first and rebuild only what is still live. Confirm the question inventory before quoting. |
| Logic and hidden fields | Branching, calculated values and hidden fields must be recreated and tested in Formbricks, and complex logic takes the most testing time. | Simplify logic where the business allows. Ask for a test matrix in the written scope. |
| Uploaded file volume | Files are retrieved through Typeform's file download endpoints, then stored on your own servers. Total size drives transfer time and storage sizing. | Inventory files per form and archive old ones separately. Confirm where files will be kept before cutover. |
| Historical response export | The Responses API returns responses as JSON and can filter by submission date, but it may omit roughly the last 30 minutes of submissions, so exports must be repeated near cutover. | Plan a cutover date, run a full export, then run a final delta export after the freeze. |
| Integrations, webhooks and embeds | Each webhook, Zapier or n8n flow and embedded form on a website or app must be repointed and verified. Formbricks offers webhooks and integrations, but mappings are not automatic. | List every integration owner before scoping. Ask who signs off each repointed flow. |
| Languages | Multi-language surveys are supported in the Community Edition, but each translation must be entered and checked. | Limit languages to those with real respondents and reuse translated text where possible. |
| Enterprise license need | Self-hosted Formbricks requires an Enterprise License Key for OIDC and SAML SSO, teams and access roles, contact management, quotas, audit logs and removing the Powered by Formbricks badge. The key is a recurring licence cost, and its price comes from Formbricks, not DeployOpen. | Decide early which of these features you truly need. Ask Formbricks for current licence terms before budgeting. |
| Hosting and operations | Your own servers, Docker or Helm deployment, backups, patching and monitoring are recurring costs paid to your infrastructure team or cloud provider. | Standardize on one deployment method and reuse existing backup and monitoring tooling. |
| Cutover window and parallel running | Running Typeform and Formbricks side by side extends the period you pay for both, and any gap loses submissions. | Shorten the window by pre-building forms, then ask the implementer for a written cutover runbook. |
Questions teams ask before they migrate from Typeform to Formbricks
How long does a Typeform to Formbricks migration take?
The duration depends mostly on how many forms you have, how complex their logic and hidden fields are, and how many years of responses and uploaded files you need to keep. No supplied source gives a standard timeline, so treat any number as a planning estimate until your own inventory is complete. A small set of link surveys with no branching can be rebuilt quickly, while forms with nested logic, calculated fields, integrations and large file archives take longer. Ask any outside provider for a fixed-scope plan with deliverables and dates agreed in writing before work starts.
Can our team migrate from Typeform to Formbricks without outside help?
Yes, a team with a Docker host, someone who can administer it, and a person who knows the forms can do the move in-house. The work has three parts: rebuilding each form as a Formbricks survey, pulling historical responses and files through the Typeform Responses API, and switching webhooks and embeds. Teams that lack container operations experience, or that must meet a compliance assessment, often bring in an implementation partner for hardening, backups and documentation. DeployOpen implements, hardens and documents self-hosted platforms in your own environment under a written scope, but the decision belongs to your team.
What does our team need to provide for a Formbricks migration?
You need an inventory of every Typeform form, its active embeds and webhooks, and the integrations that consume its data. Assign an owner for each form who can confirm the questions, logic, hidden fields and thank-you behavior. On the infrastructure side, you need a host where Formbricks will run in Docker, backup storage, a domain with TLS, and an email service for notifications. Plan a cut-over date and agree who approves it, because Typeform's Responses API may not return submissions from roughly the last 30 minutes, so freeze or announce the switch first.
Is the free Formbricks Community Edition enough to replace Typeform?
For many teams it covers the core work. The self-hosted Community Edition includes unlimited surveys, responses and users, full API access, link, website, app and email surveys, multi-language surveys, advanced logic, file upload and webhooks. Its main limit is a single workspace. It also omits OIDC and SAML SSO, teams and access roles, contact management and segments, quota management, audit logs, whitelabel email follow-ups and removal of the Powered by Formbricks badge. If you need any of those, factor an Enterprise license into the plan. Confirm the current edition details with Formbricks before you decide.
When do we need a Formbricks Enterprise license key for SSO and roles?
You need an Enterprise License Key for OIDC and SAML single sign-on, teams and access roles, and the other enterprise features listed in the license documentation. The enterprise code ships inside the Docker images and is unlocked only with that key, while the core application remains under AGPLv3. If your security team requires centralized sign-in or role separation from day one, make the key a line item in your decision, not an afterthought. Ask Formbricks for current license terms in writing, including what a key covers and how renewals work.
How do we export Typeform responses and uploaded files before we leave?
Use the Typeform Responses API, which returns a form's responses as JSON on each GET request and can filter by submission date. Pull in date-bounded batches, store the raw JSON, and then run a second pass for submissions made after the first pull. Because the API may omit roughly the last 30 minutes of submissions, your final sweep must start after the freeze. Uploaded files require their own download step through the file endpoints described in Typeform's developer documentation. Keep checksums and a manifest so you can prove that every response and file arrived intact.
What breaks when we switch Typeform webhooks and embeds to Formbricks?
The most common breaks are payload mismatches, changed field identifiers, and embeds that point to the old Typeform URL. Map each Typeform field to its Formbricks question ID before you change any consuming system, then test webhook receivers with sample submissions. Formbricks integrates with tools such as Slack, Notion, Zapier and n8n, but you should confirm that each connector you rely on behaves the way your downstream systems expect. Keep the Typeform form live in read-only or redirect mode until every embed and integration is verified.
What recurring costs should we expect after moving to self-hosted Formbricks?
The license fee for the Community Edition is zero, but self-hosting has recurring costs: the infrastructure that runs Docker, storage and backups for responses and files, the staff time to patch and monitor the platform, and any Enterprise license or support contract you choose. Those costs replace the per-plan subscription you pay Typeform, which is tiered by monthly responses and seats. Ask any provider for a quote that separates one-time migration work from recurring hosting, upgrades and support, and check the Typeform pricing page for your current plan limits before comparing totals.
How DeployOpen scopes and runs a Typeform to Formbricks migration
A Typeform to Formbricks move touches forms, logic, historical responses, uploaded files and live integrations, so each step needs a written scope before work starts. The cards below follow the order DeployOpen uses: agree the scope, stand up Formbricks in your environment, move the data, cut over and keep the platform supported afterward.
Written scope before any work
The engagement starts with a written scope that lists every Typeform form in play, which ones are rebuilt, which are retired, and which integrations depend on them. Deliverables, timelines and responsibilities are agreed in writing before work begins, so there is a clear record of what the migration covers. Ask for the form inventory to be attached to the scope, since unlisted forms are the most common source of surprises at cutover.
Formbricks in your infrastructure
DeployOpen installs self-hosted Formbricks in your own cloud account, data center or air-gapped network, so forms, responses and uploaded files never sit with a third party. The team sets up the Docker deployment, database, storage for uploads and access controls. Confirm early which region and hosting model your data rules require, because that decision shapes the whole design.
Rebuilding forms and logic
Typeform screens, branching, hidden fields and calculated values are rebuilt as Formbricks link surveys, with each mapping recorded in a migration matrix. The matrix shows which logic is reproduced exactly, which is simplified, and which needs an Enterprise feature or a different design. Review it with your form owners before any survey goes live, because rebuilt branching is the part most often changed without notice.
Exporting responses and files
Historical responses and uploaded files are pulled from Typeform through its Responses API with date filters, then loaded into the new instance with field names mapped to the rebuilt questions. Because the API may omit submissions from roughly the last 30 minutes, the export runs in passes and a final reconciliation checks counts per form. Agree the retention and deletion treatment for exported personal data in the scope.
Cutover, webhooks and embeds
The cutover plan sets a freeze point for each form, switches embedded links on websites and in-product pages, and repoints webhooks to Formbricks endpoints or downstream tools. Each switch has a rollback step and a named owner. Ask for a list of every place a Typeform link or embed appears, because forgotten embeds keep collecting data on the old platform after the move.
Backups, documentation and retainer support
Before cutover, DeployOpen configures backups of the Formbricks database and file storage, and documents the deployment, admin tasks and recovery steps in a runbook your team keeps. Enterprise license decisions, such as whether SSO or roles are needed, are recorded with their reasons. After go-live, optional retainer support covers upgrades, monitoring and continuous testing. Ask for the backup restore test results to be part of the handover.
