mirror/formbricks
1
0
Fork 0
mirror of https://github.com/formbricks/formbricks.git synced 2026-05-04 11:30:38 -05:00
Code Issues Packages Projects Releases 169 Wiki Activity

feat: new documentation (#4735)

Browse Source
This commit is contained in:
Matti Nannt
2025-02-13 21:25:12 +01:00
committed by GitHub
parent 22e8a137ef
commit f6ef3ba7c5
477 changed files with 16955 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/self-hosting/advanced/license.mdx
+107
View File
@@ -0,0 +1,107 @@
---
title: 'License'
description: "License for Formbricks"
icon: "file-certificate"
---
The Formbricks core source code is licensed under AGPLv3 and available on GitHub. Additionally, we offer features for bigger organisations & enterprises under a separate, paid Enterprise License. This assures the long-term sustainability of the open source project. All free features are listed [below](#what-features-are-free).
<Note>
Want to get your hands on the Enterprise Edition? Request a free 30-day Enterprise Edition trial by [filling out the form below.](#30-day-trial-license-request) No call needed or strings attached 🤙
</Note>
## Enterprise Edition
Additional to the AGPLv3 licensed Formbricks core, the Formbricks repository contains code licensed under our [Enterprise License](https://github.com/formbricks/formbricks/blob/main/apps/web/modules/ee/LICENSE). This additional functionality is not part of the AGPLv3 licensed Formbricks core and is designed to meet the needs of larger teams and enterprises. This advanced functionality is already included in the Docker images, but you need an **Enterprise License Key** to unlock it. For the pricing, please refer to [Formbricks Pricing](https://formbricks.com/pricing) or [get in touch](https://cal.com/johannes/license).
## When do I need an Enterprise License?
| | Community Edition | Enterprise License |
| ------------------------------------------------------------- | ----------------- | ------------------ |
| Self-host for commercial purposes | ✅ | No license needed |
| Fork codebase, make changes, release under AGPLv3 | ✅ | No license needed |
| Fork codebase, make changes, **keep private** | ❌ | ✅ |
| Unlimited responses | ✅ | No license needed |
| Unlimited surveys | ✅ | No license needed |
| Unlimited users | ✅ | No license needed |
| Projects | 3 | Unlimited |
| Use any of the other [free features](#what-features-are-free) | ✅ | No license needed |
| Remove branding ⚠️ Changed with 3.0 ⚠️ | ❌ | ✅ |
| SSO ⚠️ Changed with 3.0 ⚠️ | ❌ | ✅ |
| Contacts & Targeting ⚠️ Changed with 3.0 ⚠️ | ❌ | ✅ |
| Teams & access roles | ❌ | ✅ |
| Cluster support | ❌ | ✅ |
| Use any of the [paid features](#what-features-are-free) | ❌ | ✅ |
Ready to get started with the Enterprise Edition? Fill out our form below and we'll reach out to you.
## 30-day Trial License Request
Many organisations want to do an internal test run with the Enterprise Edition. To make that really easy, we offer a 30-day trial license. Just fill out the form below and we'll send you a license key within 24 hours (business days):
<div
style={{
position: "relative",
height: "100vh",
maxHeight: "100vh",
overflow: "auto",
borderRadius: "12px",
}}
>
<iframe src="https://app.formbricks.com/s/clvupq3y205i5yrm3sm9v1xt5" style={{ position: "absolute", left: 0, top: 0, width: "100%", height: "100%", border: 0 }} />
</div>
## Open Core Licensing
### The AGPL Formbricks Core
The Formbricks core application is licensed under the [AGPLv3 Open Source License](https://github.com/formbricks/formbricks/blob/main/LICENSE). The core application is fully functional and includes everything you need to design & run link surveys, website surveys and in-app surveys. You can use the software for free for personal and commercial use. You're also allowed to create and distribute modified versions as long as you document the changes you make incl. date and **publish your complete code under the AGPLv3 license as well.**
### The Enterprise Edition
Additional to the AGPL licensed Formbricks core, this repository contains code licensed under an Enterprise license. The [code](https://github.com/formbricks/formbricks/tree/main/apps/web/modules/ee) and [license](https://github.com/formbricks/formbricks/blob/main/apps/web/modules/ee/LICENSE) for the enterprise functionality can be found in the `/apps/web/modules/ee` folder of this repository. This additional functionality is not part of the AGPLv3 licensed Formbricks core and is designed to meet the needs of larger teams and enterprises. This advanced functionality is already included in the Docker images, but you need an [Enterprise License Key](https://formbricks.com/docs/self-hosting/enterprise) to unlock it.
## White-Labeling Formbricks and Other Licensing Needs
We currently do not offer Formbricks white-labeled. Any other needs? [Send us an email](mailto:hola@formbricks.com).
## Why charge for Enterprise Features?
The Enterprise Edition allows us to fund the development of Formbricks sustainably. It guarantees that the open-source surveying infrastructure we're building will be around for decades to come.
## What features are free?
| Feature | Community Edition | Enterprise Edition |
| ---------------------------------------------- | ----------------- | ------------------ |
| Unlimited surveys | ✅ | ✅ |
| Website & App surveys | ✅ | ✅ |
| Link surveys | ✅ | ✅ |
| Email embedded surveys | ✅ | ✅ |
| Advanced logic | ✅ | ✅ |
| Custom styling | ✅ | ✅ |
| Custom URL | ✅ | ✅ |
| Recall information | ✅ | ✅ |
| All question types | ✅ | ✅ |
| Multi-media backgrounds | ✅ | ✅ |
| Partial responses | ✅ | ✅ |
| File upload | ✅ | ✅ |
| Hidden fields | ✅ | ✅ |
| Single-use links | ✅ | ✅ |
| Pin-protected surveys | ✅ | ✅ |
| Full API Access | ✅ | ✅ |
| All SDKs | ✅ | ✅ |
| Webhooks | ✅ | ✅ |
| Email follow-ups | ✅ | ✅ |
| Multi-language UI | ✅ | ✅ |
| All integrations (Slack, Zapier, Notion, etc.) | ✅ | ✅ |
| Remove branding | ❌ | ✅ |
| Teams & access roles | ❌ | ✅ |
| Contact management & segments | ❌ | ✅ |
| AI analysis | ❌ | ✅ |
| Multi-language surveys | ❌ | ✅ |
| Single sign-on (SSO) | ❌ | ✅ |
| Helm charts | ❌ | ✅ |
| White-glove onboarding | ❌ | ✅ |
| Support SLAs | ❌ | ✅ |
**Any more questions?**: [Send us an email](mailto:johannes@formbricks.com) or [book a call with us.](https://cal.com/johannes/license)
docs/self-hosting/advanced/migration.mdx
+960
View File
@@ -0,0 +1,960 @@
---
title: "Migration"
icon: "arrow-right"
---
### v3.1
<Info>
With Formbricks 3.0, we introduced an automatic data migration system. If you're using a version older than **v2.7**, you must upgrade step-by-step through earlier versions (e.g. **2.4 → 2.5 → 2.6 → 2.7**). Once you reach **v2.7**, you can upgrade directly to **any v3.x or future release** without needing intermediate migrations.
</Info>
### Steps to Migrate
This guide is for users who are **self-hosting Formbricks** using the **one-click setup**. If you have a different setup, you may need to adjust the commands accordingly.
Before running these steps, **navigate to the `formbricks` directory** where your `docker-compose.yml` file is located.
1. **Backup your Database**: Backing up your database is crucial before upgrading. Use the following command to create a backup:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v3.1_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “**No such container**”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
1. Pull the latest version of Formbricks:
```bash
docker compose pull
```
1. Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
1. Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
When you start the latest version of **Formbricks**, it will **automatically detect and apply any required data migrations** during startup. You don’t need to run any manual migration steps or download separate migration images.
* Access your updated instance
Once the containers are running, simply go to the **same URL** as before to access your updated **Formbricks** instance.
That’s it! This new process ensures your **Formbricks** setup stays up to date with the latest schema changes as soon as you run the updated container.
## v3.0
<Warning>
**Important: Do Not Upgrade to 3.0 If You Need SSO, User Identification, or Cluster Support**
With **Formbricks 3.0**, we're making changes to ensure long-term sustainability while still supporting open source. While the **Community Edition** has gained [new features](https://formbricks.com/blog/formbricks-3-0), some [advanced capabilities](https://formbricks.com/docs/self-hosting/license) are now part of the **Enterprise Edition**.
⚠️ **No Downgrade Option:** If you upgrade to **3.0** and run the data migration, **you cannot revert to 2.7.2**. If you rely on **SSO, user identification, or cluster support**, either **stay on version 2.7.x** or [reach out](https://formbricks.com/cdn-cgi/l/email-protection#1e7671727f5e78716c737c6c777d756d307d7173) **for a custom quote**.
</Warning>
This major release brings a better approach to **data migrations**.
* If you're using **Formbricks v2.7 or later**, you can upgrade **directly** to **v3.x** and future versions.
* If you're on a version **older than v2.7**, you **must upgrade step-by-step** (e.g. **2.4 → 2.5 → 2.6 → 2.7**) before moving to v3.x.
### Steps to Migrate
This guide is for users **self-hosting** Formbricks with the **one-click setup**. If you're using a different setup, you may need to adjust the commands.
* &#x20;Navigate to the Formbricks Directory
Before running any steps, go to the directory where your `docker-compose.yml` file is located.
* Backup Your Database
Backing up your database is **crucial** before upgrading. Use the following command to create a backup:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v3.0_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
**Note:** If you see a “No such container” error, run `docker ps` to find your actual container name (e.g. `formbricks_postgres_1`).
</Info>
<Info>
Tip: If you want to store the backup as a `.sql` file, remove the `-Fc` (custom format) option. If you need to restore it later, use `psql` with an empty Formbricks database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
When you start the latest version of Formbricks, it will automatically detect and run any necessary data migrations during startup. There is no need to run any manual migration steps or pull any separate migration images.
* Access your updated instance
That’s it! Once the containers are up and running, simply navigate to the same URL as before to access your fully migrated Formbricks instance.
## v2.7
<Info>
AI Features & Database Update: This release lays the groundwork for upcoming AI features, now in private beta. Formbricks requires the `pgvector` extension in PostgreSQL.
One-Click Setup Users: Use the `pgvector/pgvector:pg15` image instead of `postgres:15-alpine` to ensure compatibility.
</Info>
Formbricks v2.7 includes all the features and improvements developed by the community during Hacktoberfest 2024. Additionally, this release introduces an advanced team-based access control system, which is available in the Formbricks Enterprise Edition.
### Additional Updates
If you previously used organisation-based access control (an enterprise feature) and the `DEFAULT_ORGANIZATION_ROLE` environment variable, update its value to one of these roles: `owner`, `manager`, or `member`. Read more about the new roles in the [documentation](/global/access-roles).
### Steps to Migrate
This guide is for users who are self-hosting Formbricks using our one-click setup. If you are using a different setup, you might adjust the commands accordingly.
To run all these steps, please navigate to the Formbricks folder where your `docker-compose.yml` file is located.
* **Backup your Database:** This is a crucial step. Please make sure to backup your database before proceeding with the upgrade. You can use the following command to backup your database.&#x20;
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.7_$(date +%Y%m%d_%H%M%S).dump
```
<Note>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Note>
<Note>
If you want to store the backup as an \*.sql file, remove the `-Fc` option. To restore, use `psql` with an empty Formbricks database.
</Note>
* If you use an older `docker-compose.yml` file from the one-click setup, modify it to use the `pgvector/pgvector:pg15` image instead of `postgres:15-alpine`:
```yaml
services:
postgres:
image: pgvector/pgvector:pg15
volumes:
- postgres:/var/lib/postgresql/data
environment:
- POSTGRES_DB=postgres
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
ports:
- 5432:5432
```
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance and remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Tip>
To find the Docker network name for your Postgres database, run `docker network ls`.
</Tip>
```bash
docker pull ghcr.io/formbricks/data-migrations:latest && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.7" \
ghcr.io/formbricks/data-migrations:v2.7.0
```
The command above will migrate your data to the latest schema. This step is important to update your existing data to the new structure. The changes will only be made if the script runs successfully. You can run the script multiple times safely.
* That's it! Once the migration is finished, you can **access your Formbricks instance** at the same URL as before.
## v2.6
Formbricks v2.6 introduces advanced logic jumps for surveys, allowing more complex branching logic, including variables, conditions, and more. This release also includes numerous bug fixes, significant performance improvements for website and app surveys, and enhanced stability.
<Info>
This release includes the final step of deprecating server-side action tracking (previously used for segment filtering by performed actions). The migrations will delete all tracked actions from the database. If you still need these action records, ensure you export them before upgrading.
</Info>
### Steps to Migrate
This guide is for users who are self-hosting Formbricks using our one-click setup. If you're using a different setup, you might need to adjust the commands accordingly.
To run these steps, navigate to the folder where your `docker-compose.yml` file is located.
* **Backup your Database:** This is an important step. Make sure to back up your database before proceeding with the upgrade. You can use this command to back up your database:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.6_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you get a "No such container" error, run `docker ps` to find your container name, for example, `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario, you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find the Docker network name for your Postgres database, run the command:
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:latest && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.6" \
ghcr.io/formbricks/data-migrations:v2.6.0
```
The command above will migrate your data to the latest schema. This is an important step to update your existing data to the new structure. Changes will only be made if the script runs successfully. You can run the script multiple times without issues.
* Once the migration is complete, **you can access your Formbricks instance** at the same URL as before.
## v2.5
Formbricks v2.5 lets you visualise responses in a data table format. This release also brings a few bug fixes and performance improvements.
<Info>
This release fixes the inconsistency of CTA and consent question values when a question is skipped. The value will now be set to an empty string instead of "dismissed" to maintain consistency with other questions.
</Info>
### Steps to Migrate
This guide is for users self-hosting Formbricks with our one-click setup. If you're using a different setup, you may need to adjust the commands.
To begin, navigate to the folder where your `docker-compose.yml` file is located.
* **Backup your Database**: This step is important. Please make sure to back up your database before upgrading. You can use the following command to back up your database:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.5_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g.`formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker Network name for your Postgres Database, find it using `docker network ls`
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:latest && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.5" \
ghcr.io/formbricks/data-migrations:v2.5.3
```
The command will migrate your data to the latest schema, ensuring your existing data is updated to the new structure. Changes will only be made if the script runs successfully, and you can safely run the script multiple times.
* Once the migration is complete, **you can access your Formbricks instance** at the same URL as before.
## v2.4
Formbricks v2.4 lets you create multiple endings for your surveys and choose which one users see based on logic jumps. This version also includes bug fixes and performance improvements.
<Info>
This release will remove support for advanced targeting (enterprise targeting for app surveys) using actions (e.g. targeting users who triggered action x 3 times in the last month). Actions can still be used as triggers, but they will no longer be stored on the server to improve Formbricks' overall performance.
</Info>
### Steps to Migrate
This guide is for users who are self-hosting Formbricks with our one-click setup. If you're using a different setup, you may need to adjust the commands accordingly.
To follow these steps, go to the folder where your `docker-compose.yml` file is located.
1. **Backup your Database**: This step is important. Please make sure to back up your database before upgrading. You can use the following command to back up your database:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.4_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as a `*.sql` file, remove the `-Fc` (custom format) option. In case of a restore scenario, you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
Now let's migrate the data to the latest schema:
To find your Docker Network name for your Postgres Database, find it using `docker network ls`
```bash
docker pull ghcr.io/formbricks/data-migrations:v2.4.3 && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.4" \
ghcr.io/formbricks/data-migrations:v2.4.3
```
The command above will migrate your data to the latest schema. This is an important step to update your data structure. Changes are only applied if the script runs successfully. You can run the script multiple times without issues.
* That's it! Once the migration is done, you can access your Formbricks instance at the same URL as before.
### Additional Updates
* The `CRON_SECRET` environment variable is now required to enhance the security of the internal cron APIs. Please ensure that this variable is set in your environment or `docker-compose.yml`. You can generate a secure secret using `openssl rand -hex 32`
## v2.3
Formbricks v2.3 introduces new colour options for rating questions, enhanced multi-language support for Chinese (Simplified & Traditional), and includes several bug fixes and performance improvements.
### Steps to Migrate
<Info>
You only need to run the data migration if you have surveys set up in Chinese (`zh`). If you don't have any surveys in Chinese, you can skip the migration step.
</Info>
This guide is for users self-hosting Formbricks with our one-click setup. If you're using a different setup, adjust the commands as needed.
To proceed, go to the folder where your `docker-compose.yml` file is located.
* **Backup your Database**: This is a crucial step. Please make sure to backup your database before proceeding with the upgrade. You can use the following command to backup your database:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.3_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “**No such containe**r”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker Network name for your Postgres Database, find it using `docker network ls`
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:v2.3.0 && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.3" \
ghcr.io/formbricks/data-migrations:v2.3.0
```
The command above will migrate your data to the latest schema, which is essential for updating your data structure. Changes will only be made if the script runs successfully. You can safely run the script multiple times.
* Once the migration is complete, **you can access your Formbricks instance** at the same URL as before.
### Additional Updates
The feature to create short URLs in Formbricks is now deprecated. Existing short URLs will continue to work for now, but it is recommended to use long URLs instead. Support for short URL redirects will be removed in a future release.
## v2.2
Formbricks v2.2 introduces XM research presets, providing a brand-new product onboarding experience. Our goal is to make user research "obviously easy" across different industries, starting with Software-as-a-Service and E-Commerce.
### Steps to Migrate
This guide is for users who are self-hosting Formbricks with our one-click setup. If you're using a different setup, you may need to adjust the commands accordingly.
To run all these steps, please navigate to the `formbricks` folder where your `docker-compose.yml` file is located.
1. **Backup your Database**: This is a crucial step. Please make sure to backup your database before proceeding with the upgrade. You can use the following command to backup your database:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.2_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker Network name for your Postgres Database, find it using `docker network ls`
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:v2.2 && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.2" \
ghcr.io/formbricks/data-migrations:v2.2
```
The command above will migrate your data to the latest schema. This is an important step to update your existing data. Changes will only be made if the script runs successfully. You can safely run the script multiple times.
* Once the migration is complete, **you can access your Formbricks instance** at the same URL as before.
### Changes in Environment Variables
* The `ONBOARDING_DISABLED` environment variable is now deprecated. We have replaced the user onboarding with a product onboarding process that only runs when creating a new product.
## v2.1
Formbricks v2.1 introduces more options for creating No-Code Actions and improves the self-hosting experience with a new onboarding process for fresh instances.
<Info>
To improve the user experience and simplify setup for self-hosting instances, we are transitioning to a single organization model. This change allows self-hosts to manage their instance centrally and more easily control access. A new permissions system will also be introduced soon, providing more granular control over projects and resources within an organization.
If you've previously created multiple organizations, you can still switch between them in the UI, but creating new organizations will no longer be possible.
</Info>
### Steps to Migrate
This guide is for users self-hosting Formbricks using our one-click setup. If you are using a different setup, you may need to adjust the commands accordingly.
To follow these steps, please navigate to the Formbricks folder where your `docker-compose.yml` file is located.
* **Backup your Database**: This is an essential step. Please ensure that you back up your database before proceeding with the upgrade. You can use the following command to back it up:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.1_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as a `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers.
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker network name for the Postgres database, run the following `docker network ls`
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:v2.1.0 && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.1" \
ghcr.io/formbricks/data-migrations:v2.1.0
```
Once the migration script runs successfully, your data will be migrated to the latest schema. The script is designed to run safely multiple times, so you don’t need to worry if it’s executed more than once. After completing the migration, you can continue to access your Formbricks instance at the same URL as before.
* That's it! Once the migration is complete, you can **now access your Formbricks instance** at the same URL as before.
### Changes in Environment Variables
* **SIGNUP\_DISABLED** is now deprecated. Self-hosting instances have signup disabled by default, and new users can only be invited by the organization owner or admin.
* **DEFAULT\_TEAM\_ID** has been renamed to **DEFAULT\_ORGANIZATION\_ID**.
* **DEFAULT\_TEAM\_ROLE** has been renamed to **DEFAULT\_ORGANIZATION\_ROLE**.
## v2.0
Formbricks v2.0 introduces significant features such as **Multi-Language Surveys** and **Advanced Styling for Surveys**, aimed at improving the flexibility and appearance of your surveys. Additionally, the release includes several optimisations, bug fixes, and smaller improvements to ensure a smoother user experience.
If you are upgrading to Formbricks v2.0, follow this guide to ensure a smooth migration of your existing Formbricks instance without encountering issues or build errors.
<Info>
This upgrade requires a **data migration**. Please make sure to back up your database before proceeding. Follow the steps below to upgrade your Formbricks instance to v2.0.
</Info>
<Info>
If you've used the Formbricks Enterprise Edition with a free beta license key, your instance will be downgraded to the Community Edition 2.0. You can find all license details on the [license page](https://formbricks.com/docs/self-hosting/license).
</Info>
<Warning>
We are moving from DockerHub to GitHub Packages for our images. If you are still pulling the images from DockerHub please change `image: formbricks/formbricks:latest` to `image:ghcr.io/formbricks/formbricks:latest` in your `docker-compose.yml` file.
</Warning>
### Steps to Migrate
This guide is for users who are self-hosting Formbricks using our one-click setup. If you are using a different setup, you might adjust the commands accordingly.
To run all these steps, please navigate to the `formbricks` folder where your `docker-compose.yml` file is located.
1. **Backup your Database**: This is an essential step. Please ensure that you back up your database before proceeding with the upgrade. You can use the following command to back it up:
```bash
docker exec formbricks-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v2.0_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
If you prefer storing the backup as an `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
* Pull the latest version of Formbricks:
```bash
docker compose pull
```
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers with the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker Network name for your Postgres Database, find it using `docker network ls`
</Info>
```bash
docker pull ghcr.io/formbricks/data-migrations:v2.0.3 && \
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v2.0" \
ghcr.io/formbricks/data-migrations:v2.0.3
```
The above command will migrate your data to the latest schema. This is a crucial step to migrate your existing data to the new structure. Only if the script runs successful, changes are made to the database. The script can safely run multiple times.
* That's it! Once the migration is complete, you can **now access your Formbricks instance** at the same URL as before.
### App Surveys with @formbricks/js
With this upgrade, we now dynamically fetch the package from our API endpoint and have updated the package entry points to support both app and website surveys. This ensures that you always have the latest version of the package (v2.0.0+).
**Old approach:** (v1.6.5)
```ts
import formbricks from "@formbricks/js";
formbricks.init({
environmentId: "<environment-id>",
apiHost: "<api-host>",
userId: "<user-id>", // optional
});
```
**New approach:** (v2.0.0)
Website surveys:
```ts
import formbricks from "@formbricks/js/website";
formbricks.init({
environmentId: "<environment-id>",
apiHost: "<api-host>",
// userId is not supported here
});
```
App surveys:
```ts
import formbricks from "@formbricks/js/app";
formbricks.init({
environmentId: "<environment-id>",
apiHost: "<api-host>",
userId: "<user-id>", // required
});
```
## v1.6
Formbricks v1.6 introduces key features like Advanced Targeting, Segmentation, on-the-fly survey triggers, and stability improvements. This update also changes some environment variables. Follow this guide to upgrade your Formbricks instance to v1.6 smoothly.
<Info>
This upgrade requires a data migration. Ensure you back up your database before proceeding. Follow the steps below to upgrade your Formbricks instance to v1.6.
</Info>
### Steps to Migrate
This guide is for users self-hosting Formbricks with our one-click setup. If you're using a different setup, adjust the commands accordingly.
Navigate to the Formbricks folder containing your `docker-compose.yml` file to run the steps.
* **Backup your Database**: This is a crucial step. Please make sure to backup your database before proceeding with the upgrade. You can use the following command to backup your database:
```bash
docker exec formbricks-quickstart-postgres-1 pg_dump -Fc -U postgres -d formbricks > formbricks_pre_v1.6_$(date +%Y%m%d_%H%M%S).dump
```
<Info>
If you run into “No such container”, use `docker ps` to find your container name, e.g. `formbricks_postgres_1`.
</Info>
<Info>
If you prefer storing the backup as a `*.sql` file remove the `-Fc` (custom format) option. In case of a restore scenario you will need to use `psql` then with an empty `formbricks` database.
</Info>
* Stop the running Formbricks instance & remove the related containers:
```bash
docker compose down
```
* Restarting the containers will automatically pull the latest version of Formbricks:
```bash
docker compose up -d
```
* Now let's migrate the data to the latest schema:
<Info>
To find your Docker Network name for your Postgres Database, find it using `docker network ps`
</Info>
```bash
docker run --rm \
--network=formbricks_default \
-e DATABASE_URL="postgresql://postgres:postgres@postgres:5432/formbricks?schema=public" \
-e UPGRADE_TO_VERSION="v1.6" \
ghcr.io/formbricks/data-migrations:v1.6.1
```
The above command will migrate your data to the latest schema. This is a crucial step to migrate your existing data to the new structure. Only if the script runs successful, changes are made to the database. The script can safely run multiple times.
1. That's it! Once the migration is complete, you can **now access your Formbricks instance** at the same URL as before.
#### Restoring the database after a failed upgrade
```bash
docker exec -i formbricks-quickstart-postgres-1 pg_restore --clean -U postgres -v -d formbricks < formbricks_pre_v1.6_<timestamp_of_your_dump_file>.dump
```
<Info>
Replace the path to `formbricks_pre_v1.6_<timestamp_of_your_dump_file>.dump` with the exact path to your `.dump` file.
</Info>
<Info>
This will wipe the database and restore from the `.dump` file.
</Info>
### App Surveys with `@formbricks/js`
If you're using the `@formbricks/js` package, update it to version \~1.6.5 to access the latest features and improvements.
<Info>
Currently, the package needs to be pinned to `~1.6.5`, see [this issue](https://github.com/formbricks/formbricks/issues/2273).
</Info>
### Upgrade and pin the client package
```bash
npm install @formbricks/js@~1.6.5
```
### Deprecated Environment Variables
| Environment Variable | Comments |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GITHUB_AUTH_ENABLED` | Was used to enable GitHub OAuth, but from v1.6, you can just set the `GITHUB_ID` and `GITHUB_SECRET` environment variables. |
| `GOOGLE_AUTH_ENABLED` | Was used to enable Google OAuth, but from v1.6, you can just set the `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` environment variables. |
| `AZUREAD_AUTH_ENABLED` | Was used to enable AzureAD OAuth, but from v1.6, you can just set the `AZUREAD_CLIENT_ID`, `AZUREAD_CLIENT_SECRET` & `AZUREAD_TENANT_ID` environment variables. |
## v1.2
Formbricks v1.2 introduces new features for Link Surveys and enhances security. However, there are some breaking changes related to environment variables. This guide will help you upgrade your Formbricks instance to v1.2 smoothly.
### New Environment Variables
| Environment Variable | Required | Recommended Generation | Comments |
| -------------------- | -------- | ----------------------- | ----------------------------------------------------------- |
| `ENCRYPTION_KEY` | true | `openssl rand -hex 32` | Needed for 2 Factor Authentication |
| `SHORT_URL_BASE` | false | `<your-short-base-url>` | Needed if you want to enable shorter links for Link Surveys |
### Deprecated / Removed Environment Variables
| Environment Variable | Comments |
| -------------------- | --------------------------------------------------------------------------- |
| `SURVEY_BASE_URL` | The `WEBAPP_URL` is now used to determine the survey base URL in all places |
## v1.1
Formbricks v1.1 introduces new features and improvements but includes breaking changes with environment variables. This guide will help you upgrade your Formbricks instance to v1.1 without data loss.
### Renamed Environment Variables
| till v1.0 | v1.1 |
| ----------------------------------------- | ----------------------------- |
| `NEXT_PUBLIC_EMAIL_VERIFICATION_DISABLED` | `EMAIL_VERIFICATION_DISABLED` |
| `NEXT_PUBLIC_PASSWORD_RESET_DISABLED` | `PASSWORD_RESET_DISABLED` |
| `NEXT_PUBLIC_SIGNUP_DISABLED` | `SIGNUP_DISABLED` |
| `NEXT_PUBLIC_INVITE_DISABLED` | `INVITE_DISABLED` |
| `NEXT_PUBLIC_PRIVACY_URL` | `PRIVACY_URL` |
| `NEXT_PUBLIC_TERMS_URL` | `TERMS_URL` |
| `NEXT_PUBLIC_IMPRINT_URL` | `IMPRINT_URL` |
| `NEXT_PUBLIC_GITHUB_AUTH_ENABLED` | `GITHUB_AUTH_ENABLED` |
| `NEXT_PUBLIC_GOOGLE_AUTH_ENABLED` | `GOOGLE_AUTH_ENABLED` |
| `NEXT_PUBLIC_WEBAPP_URL` | `WEBAPP_URL` |
| `NEXT_PUBLIC_IS_FORMBRICKS_CLOUD` | `IS_FORMBRICKS_CLOUD` |
| `NEXT_PUBLIC_SURVEY_BASE_URL` | `SURVEY_BASE_URL` |
Please note that their values and the logic remains exactly the same. Only the prefix has been deprecated. The other environment variables remain the same as well.
### Deprecated Environment Variables
* **`NEXT_PUBLIC_VERCEL_URL`**: Was used as Vercel URL (used instead of `WEBAPP_URL)`, but from v1.1, you can just set the `WEBAPP_URL` environment variable to your Vercel URL.
* **`RAILWAY_STATIC_URL`**: Was used as Railway Static URL (used instead of `WEBAPP_URL`), but from v1.1, you can just set the `WEBAPP_URL` environment variable.
* **`RENDER_EXTERNAL_URL`**: Was used as an external URL to Render (used instead of `WEBAPP_URL`), but from v1.1, you can just set the `WEBAPP_URL` environment variable.
* **`HEROKU_APP_NAME`**: Was used to build the App name on a Heroku hosted webapp, but from v1.1, you can just set the `WEBAPP_URL` environment variable.
* **`NEXT_PUBLIC_WEBAPP_URL`**: Was used for the same purpose as `WEBAPP_URL`, but from v1.1, you can just set the `WEBAPP_URL` environment variable.
* **`PRISMA_GENERATE_DATAPROXY`**: Was used to tell Prisma that it should generate the runtime for Dataproxy usage. But its officially deprecated now.
### Helper Shell Script
For a seamless migration, below is a shell script for your self-hosted instance that will automatically update your environment variables to be compliant with the new naming conventions.
### Docker & Single Script Setup
Now that these variables can be defined at runtime, you can append them inside your `x-environment` in the `docker-compose.yml` itself.
For a more detailed guide on these environment variables, please refer to the [Important Runtime Variables](/self-hosting/docker#important-run-time-variables) section.
```yaml docker-compose.yml
version: "3.3"
x-environment: &environment
environment:
# The url of your Formbricks instance used in the admin panel
WEBAPP_URL:
# Required for next-auth. Should be the same as WEBAPP_URL
NEXTAUTH_URL:
# PostgreSQL DB for Formbricks to connect to
DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/formbricks?schema=public"
# NextJS Auth
# @see: https://next-auth.js.org/configuration/options#nextauth_secret
# You can use: `openssl rand -hex 32` to generate one
NEXTAUTH_SECRET:
# PostgreSQL password
POSTGRES_PASSWORD: postgres
# Email Configuration
MAIL_FROM:
SMTP_HOST:
SMTP_PORT:
SMTP_SECURE_ENABLED:
SMTP_USER:
SMTP_PASSWORD:
# Uncomment the below and set it to 1 to disable Email Verification for new signups
# EMAIL_VERIFICATION_DISABLED:
# Uncomment the below and set it to 1 to disable Password Reset
# PASSWORD_RESET_DISABLED:
# Uncomment the below and set it to 1 to disable Signups
# SIGNUP_DISABLED:
# Uncomment the below and set it to 1 to disable loging in with email
# EMAIL_AUTH_DISABLED:
# Uncomment the below and set it to 1 to disable Invites
# INVITE_DISABLED:
# Uncomment the below and set a value to have your own Privacy Page URL on the signup & login page
# PRIVACY_URL:
# Uncomment the below and set a value to have your own Terms Page URL on the auth and the surveys page
# TERMS_URL:
# Uncomment the below and set a value to have your own Imprint Page URL on the auth and the surveys page
# IMPRINT_URL:
# Uncomment the below and set to 1 if you want to enable GitHub OAuth
# GITHUB_AUTH_ENABLED:
# GITHUB_ID:
# GITHUB_SECRET:
# Uncomment the below and set to 1 if you want to enable Google OAuth
# GOOGLE_AUTH_ENABLED:
# GOOGLE_CLIENT_ID:
# GOOGLE_CLIENT_SECRET:
```
If you have any questions or require help, feel free to reach out to us on [**GitHub Discussions**](https://github.com/formbricks/formbricks/discussions). 😃[
](https://formbricks.com/docs/developer-docs/rest-api)
docs/self-hosting/advanced/rate-limiting.mdx
+41
View File
@@ -0,0 +1,41 @@
---
title: "Rate Limiting"
description: "Rate limiting for Formbricks"
icon: "timer"
---
To protect the platform from abuse and ensure fair usage, rate limiting is enforced by default on an IP-address basis. If a client exceeds the allowed number of requests within the specified time window, the API will return a `429 Too Many Requests` status code.
## Default Rate Limits
The following rate limits apply to various endpoints:
| **Endpoint** | **Rate Limit** | **Time Window** |
| ----------------------- | -------------- | --------------- |
| `POST /login` | 30 requests | 15 minutes |
| `POST /signup` | 30 requests | 60 minutes |
| `POST /verify-email` | 10 requests | 60 minutes |
| `POST /forgot-password` | 5 requests | 60 minutes |
| `GET /client-side-api` | 100 requests | 1 minute |
| `POST /share` | 100 requests | 60 minutes |
If a request exceeds the defined rate limit, the server will respond with:
```json
{
"code": 429,
"error": "Too many requests, Please try after a while!"
}
```
## Disabling Rate Limiting
For self-hosters, rate limiting can be disabled if necessary. However, we **strongly recommend keeping rate limiting enabled in production environments** to prevent abuse.
To disable rate limiting, set the following environment variable:
```bash
RATE_LIMITING_DISABLED=1
```
After making this change, restart your server to apply the new setting.
docs/self-hosting/configuration/custom-ssl.mdx
+149
View File
@@ -0,0 +1,149 @@
---
title: "Custom SSL Certificate"
description: "Using Formbricks One-Click Setup with a Custom SSL Certificate."
icon: "lock"
---
<Note>
Formbricks One-Click setup already comes with a valid SSL certificate using **Let's Encrypt**. This guide is only if you already have a valid SSL certificate that you need to use due to company policy or other requirements.
</Note>
Formbricks' One-Click setup automatically creates an SSL certificate using **Let's Encrypt**. However, some setups need a custom SSL certificate. This is common for intranets or systems with special certificate rules that use an internal or custom certificate authority (CA).
### Step 1: Navigate to the Formbricks Folder
Move into the `formbricks/` directory:
```bash
cd formbricks
```
### Step 2: Create a Folder for SSL Certificates
Create a folder called `certs` and place your SSL certificate files inside:
```bash
mkdir certs
# Move your SSL certificate files to the certs folder
mv /path/to/your/fullchain.crt certs/
mv /path/to/your/cert.key certs/
```
### Step 3: Understand SSL Certificate Files
* **fullchain.crt** – Your SSL certificate, including the full certificate chain.
* **cert.key** – The private key used to encrypt data.
### Step 4: Set Correct File Permissions
Ensure the certificate files have the right permissions:
```bash
sudo chown root:root certs/*
sudo chmod 600 certs/*
```
### Step 5: Update `traefik.yaml`
Modify the file to define HTTP and HTTPS settings:
<CodeGroup>
```yaml traefik.yaml
entryPoints:
web:
address: ":80"
http:
redirections:
entryPoint:
to: websecure
scheme: https
permanent: true
websecure:
address: ":443"
providers:
docker:
watch: true
exposedByDefault: false
file:
directory: /etc/traefik/dynamic
```
</CodeGroup>
### Step 6: Create `certs-traefik.yaml`
Create a `certs-traefik.yaml` file that specifies the path to your custom SSL certificate and key.
<CodeGroup>
```yaml certs-traefik.yaml
tls:
certificates:
- certFile: /certs/fullchain.crt
keyFile: /certs/cert.key
```
</CodeGroup>
### Step 7: Update `docker-compose.yml`
Modify the configuration to enforce SSL. The rest of the configuration should remain the same as the One-Click setup:
<CodeGroup>
```yaml docker-compose.yml
services:
formbricks:
restart: always
image: ghcr.io/formbricks/formbricks:latest
depends_on:
- postgres
labels:
- "traefik.enable=true" # Enable Traefik for this service
- "traefik.http.routers.formbricks.rule=Host(`my-domain.com`)" # Use your actual domain or IP
- "traefik.http.routers.formbricks.entrypoints=websecure" # Use the websecure entrypoint (port 443 with TLS)
- "traefik.http.routers.formbricks.tls=true" # Enable TLS
- "traefik.http.services.formbricks.loadbalancer.server.port=3000" # Forward traffic to Formbricks on port 3000
ports:
- 3000:3000
volumes:
- uploads:/home/nextjs/apps/web/uploads/
<<: *environment
traefik:
image: "traefik:v2.7"
restart: always
container_name: "traefik"
depends_on:
- formbricks
ports:
- "80:80"
- "443:443"
- "8080:8080"
volumes:
- ./traefik.yaml:/traefik.yaml
- ./acme.json:/acme.json
- /var/run/docker.sock:/var/run/docker.sock:ro
- ./certs:/certs
- ./certs-traefik.yaml:/etc/traefik/dynamic/certs-traefik.yaml
```
</CodeGroup>
## Summary
* **Navigate to the Formbricks folder**
* **Create a `certs/` folder** and move your certificate files inside.
* **Ensure you have the correct certificate files** (`fullchain.crt` and `cert.key`).
* **Update file permissions** for security.
* **Modify `traefik.yaml`** to handle HTTPS.
* **Create `certs-traefik.yaml`** to point to your certificate files.
* **Update `docker-compose.yml`** to use your custom SSL certificate.
This setup ensures that Formbricks securely communicates using your own SSL certificate. 🚀
If you have any questions or require help, feel free to reach out to us on [**GitHub Discussions**](https://github.com/formbricks/formbricks/discussions). 😃[
](https://formbricks.com/docs/developer-docs/rest-api)
docs/self-hosting/configuration/environment-variables.mdx
+63
View File
@@ -0,0 +1,63 @@
---
title: "Environment Variables"
description: "Environment variables for Formbricks"
icon: "code"
---
#### Custom Configurations
These variables are present inside your machine’s docker-compose file. Restart the docker containers if you change any variables for them to take effect.
| Variable | Description | Required | Default |
| ---------------------------- | -------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------- |
| WEBAPP_URL | Base URL of the site. | required | http://localhost:3000 |
| NEXTAUTH_URL | Location of the auth server. This should normally be the same as WEBAPP_URL | required | http://localhost:3000 |
| DATABASE_URL | Database URL with credentials. | required | |
| NEXTAUTH_SECRET | Secret for NextAuth, used for session signing and encryption. | required | (Generated by the user, must not exceed 32 bytes, `openssl rand -hex 32`) |
| ENCRYPTION_KEY | Secret for used by Formbricks for data encryption | required | (Generated by the user, must not exceed 32 bytes, `openssl rand -hex 32`) |
| CRON_SECRET | API Secret for running cron jobs. | required | (Generated by the user, must not exceed 32 bytes, `openssl rand -hex 32`) |
| UPLOADS_DIR | Local directory for storing uploads. | optional | ./uploads |
| S3_ACCESS_KEY | Access key for S3. | optional | (resolved by the AWS SDK) |
| S3_SECRET_KEY | Secret key for S3. | optional | (resolved by the AWS SDK) |
| S3_REGION | Region for S3. | optional | (resolved by the AWS SDK) |
| S3_BUCKET_NAME | S3 bucket name for data storage. Formbricks enables S3 storage when this is set. | optional (required if S3 is enabled) | |
| S3_ENDPOINT_URL | Endpoint for S3. | optional | (resolved by the AWS SDK) |
| PRIVACY_URL | URL for privacy policy. | optional | |
| TERMS_URL | URL for terms of service. | optional | |
| IMPRINT_URL | URL for imprint. | optional | |
| IMPRINT_ADDRESS | Address for imprint. | optional | |
| EMAIL_AUTH_DISABLED | Disables the ability for users to signup or login via email and password if set to 1. | optional | |
| PASSWORD_RESET_DISABLED | Disables password reset functionality if set to 1. | optional | |
| EMAIL_VERIFICATION_DISABLED | Disables email verification if set to 1. | optional | |
| RATE_LIMITING_DISABLED | Disables rate limiting if set to 1. | optional | |
| INVITE_DISABLED | Disables the ability for invited users to create an account if set to 1. | optional | |
| MAIL_FROM | Email address to send emails from. | optional (required if email services are to be enabled) | |
| SMTP_HOST | Host URL of your SMTP server. | optional (required if email services are to be enabled) | |
| SMTP_PORT | Host Port of your SMTP server. | optional (required if email services are to be enabled) | |
| SMTP_USER | Username for your SMTP Server. | optional (required if email services are to be enabled) | |
| SMTP_PASSWORD | Password for your SMTP Server. | optional (required if email services are to be enabled) | |
| SMTP_AUTHENTICATED | If set to 0, the server will not require SMTP_USER and SMTP_PASSWORD(default is 1) | optional | |
| SMTP_SECURE_ENABLED | SMTP secure connection. For using TLS, set to 1 else to 0. | optional (required if email services are to be enabled) | |
| SMTP_REJECT_UNAUTHORIZED_TLS | If set to 0, the server will accept connections without requiring authorization from the list of supplied CAs. | optional | 1 |
| TURNSTILE_SITE_KEY | Site key for Turnstile. | optional | |
| TURNSTILE_SECRET_KEY | Secret key for Turnstile. | optional | |
| GITHUB_ID | Client ID for GitHub. | optional (required if GitHub auth is enabled) | |
| GITHUB_SECRET | Secret for GitHub. | optional (required if GitHub auth is enabled) | |
| GOOGLE_CLIENT_ID | Client ID for Google. | optional (required if Google auth is enabled) | |
| GOOGLE_CLIENT_SECRET | Secret for Google. | optional (required if Google auth is enabled) | |
| STRIPE_SECRET_KEY | Secret key for Stripe integration. | optional | |
| STRIPE_WEBHOOK_SECRET | Webhook secret for Stripe integration. | optional | |
| TELEMETRY_DISABLED | Disables telemetry if set to 1. | optional | |
| DEFAULT_BRAND_COLOR | Default brand color for your app (Can be overwritten from the UI as well). | optional | #64748b |
| DEFAULT_ORGANIZATION_ID | Automatically assign new users to a specific organization when joining | optional | |
| DEFAULT_ORGANIZATION_ROLE | Role of the user in the default organization. | optional | owner |
| OIDC_DISPLAY_NAME | Display name for Custom OpenID Connect Provider | optional | |
| OIDC_CLIENT_ID | Client ID for Custom OpenID Connect Provider | optional (required if OIDC auth is enabled) | |
| OIDC_CLIENT_SECRET | Secret for Custom OpenID Connect Provider | optional (required if OIDC auth is enabled) | |
| OIDC_ISSUER | Issuer URL for Custom OpenID Connect Provider (should have .well-known configured at this) | optional (required if OIDC auth is enabled) | |
| OIDC_SIGNING_ALGORITHM | Signing Algorithm for Custom OpenID Connect Provider | optional | RS256 |
| OPENTELEMETRY_LISTENER_URL | URL for OpenTelemetry listener inside Formbricks. | optional | |
| CUSTOM_CACHE_DISABLED | Disables custom cache handler if set to 1 (required for deployment on Vercel) | optional | |
Note: If you want to configure something that is not possible via above, please open an issue on our GitHub repo here or reach out to us on Github Discussions and we’ll try our best to work out a solution with you.
docs/self-hosting/configuration/integrations/airtable.mdx
+63
View File
@@ -0,0 +1,63 @@
export const metadata = {
title: "Airtable (On Premise)",
description: "Instantly populate your Airtable table with survey data",
};
#### On Premise: Integrations
# Airtable (On Premise)
The Airtable integration allows you to automatically send responses to an Airtable of your choice.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/airtable) to set it up.
</Note>
## Setup
Enabling the Airtable Integration in a self-hosted environment requires creating an airtable account and changing the environment variables of your Formbricks instance.
<Note>
If your Airtable app is in development use, please ensure that the email used in the Airtable integration matches the email used in the Airtable OAuth app. To use other email addresses, you need to fill this information in your OAuth app settings again:
![airtable img](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738251900/image_eoaxg3.jpg)
</Note>
* Go to the [Airtable](https://airtable.com) and create a new account if you dont already have one.
* Click on user icon on top left and open to **Developer hub**
![opendevhub](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252268/image_l3w3an.jpg)
* Navigate to OAuth integrations and click on **Register an OAuth integrations**
![new](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252316/image_xmqyee.jpg)
* Select a name for your integration and also add a redirect URL which will be `<YOUR_WEBAPP_URL>/api/v1/integrations/airtable/callback`
![air](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252498/image_ufbmot.jpg)
* . Now fill some basic details about your integrations and then go to scope section. You need to **enable** 5 scopes:
* data.records:read
* data.records:write
* schema.bases:read
* schema.bases:write
* user.email:read
![tables](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252641/image_veqzki.jpg)
* Click on the "Save" button and you are done
* Now just copy **Client ID** for your integration & add it to your **Formbricks environment variables** as in the docker compose file:
* `AIRTABLE_CLIENT_ID`
Voila! You have successfully enabled the Airtable integration in your self-hosted Formbricks instance. Now you can follow the steps mentioned in [Airtable Integration with Formbricks](/developer-docs/integrations/airtable) section to link an Airtable with Formbricks.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/integrations/google-sheets.mdx
+92
View File
@@ -0,0 +1,92 @@
export const metadata = {
title: "Google Sheets (On Premise)",
description: "Instantly populate your Google Sheet table with survey data",
};
#### On Premise: Integrations
# Google Sheets (On Premise)
The Google Sheets integration allows you to automatically send responses to an Google Sheets of your choice.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/google-sheets) to set it up.
</Note>
## Setup
Integrating Google Sheets with a self-hosted Formbricks instance requires configuring Google Cloud and updating your environment variables.
<Note>
If your Google Cloud Console project has a publishing status of "Testing" your refresh token will expire after 7 days. To avoid that, you need to change the publishing status to "Production". [Google OAuth 2.0 documentation](https://developers.google.com/identity/protocols/oauth2?hl=en#expiration)
</Note>
* Go to the [Google Cloud Console](https://console.cloud.google.com/) and **create a new project**.
* Enable necessary APIs:
* Now select the project you just created and go to the **APIs & Services** section.
* Click on the **Enable APIs and Services** button and search for **Google Sheets API** and enable it.
* Configure OAuth Consent Screen:
* Go to **OAuth Consent screen** and select the appropriate User Type (External or Internal). Select **Internal** if you want only the users of your Google Workspace to be able to use the integration.
* Fill the required details:
* App name: Name displayed during OAuth authentication.
* User support email and Developer contact information: Your contact details for support.
* Click on **Save and Continue**.
* Add required Scopes:
* Click on the **Add or Remove Scopes** button and add the scopes:
* [`https://www.googleapis.com/auth/userinfo.email`](https://www.googleapis.com/auth/userinfo.email)
* [`https://www.googleapis.com/auth/spreadsheets`](https://www.googleapis.com/auth/spreadsheets)
* Click on the **Update** button. Verify the scopes and click on the **Save and Continue** button.
* Skip the **Test Users** section and click on the **Save and Continue** button.
* View the OAuth Consent Screen summary and click on the **Back to Dashboard** button.
* Register OAuth Client:
* Navigate to **Credentials** > **Create Credentials** > **OAuth Client ID**.
* Select **Web Application** and set:
* Name: Name of the OAuth Client ID.
* Authorized JavaScript Origins: `https://<your-public-facing-url>`
* Authorized redirect URIs: `https://<your-public-facing-url>/api/google-sheet/callback`
* Save and note the Client ID and Client Secret.
* Copy the Client ID and Client Secret and set them as environment variables in your Formbricks instance:
* `GOOGLE_SHEETS_CLIENT_ID`
* `GOOGLE_SHEETS_CLIENT_SECRET`
* `GOOGLE_SHEETS_REDIRECT_URL`
Now just copy **GOOGLE\_SHEETS\_CLIENT\_ID**, **GOOGLE\_SHEETS\_CLIENT\_SECRET** and **GOOGLE\_SHEETS\_REDIRECT\_URL** for your integration & add it to your **Formbricks environment variables** as in the docker compose file:
* `GOOGLE_SHEETS_CLIENT_ID`
* `GOOGLE_SHEETS_CLIENT_SECRET`
* `GOOGLE_SHEETS_REDIRECT_URL`
Voila! You have successfully enabled the Google Sheets integration in your self-hosted Formbricks instance. Now you can follow the steps mentioned in [Google Sheets Integration with Formbricks](/developer-docs/integrations/google-sheets) section to link a Google Sheet with Formbricks.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/integrations/n8n.mdx
+84
View File
@@ -0,0 +1,84 @@
export const metadata = {
title: "n8n (On Premise)",
description: "Set up automations with your self-hosted n8n instance.",
};
#### On Premise: Integrations
# n8n (On Premise)
The n8n integration allows you to create automations based on survey responses.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/n8n) to set it up.
</Note>
## Setup
Enabling the n8n integration in a self-hosted environment requires a new workflow setup using n8n and changing the environment variables of your Formbricks instance.
* Setup your n8n workflow: Go to [n8n.io](https://n8n.io) and create a new workflow. Search for “Formbricks” to get started:
![n8n](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252710/image_rp86wt.jpg)
* **Connect Formbricks with n8n**: Now, you have to connect n8n with Formbricks via an API Key:
![CreateNewCredentialBtn](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252823/image_kyyvur.jpg)
* Click on Create New Credentail button to add your host and API Key
![AddAPIKey](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252907/image_a1fmyc.jpg)
Now you need an API key. Please refer to the [API Key Setup](/additional-features/api#how-to-generate-an-api-key) page to learn how to create one.
Once you copied it in the API Key field, hit Save button to test the connection and save the credentials.
![connectiontest](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738252980/image_asox5o.jpg)
* Select Event: Next, you can choose the event you want to trigger the node on. You can select multiple events:
![select event](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253186/image_xrjjrh.jpg)
Here, we are adding `Response Finished` as an event, which will trigger when the survey has been filled out.
* Select Survey: Next, you can choose from all the surveys you have created in this environment. You can select multiple surveys:
![select survey](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253219/image_hbubu7.jpg)
Here, we are selecting two surveys.
![two survey](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253296/image_lbb4hw.jpg)
* Test your trigger: In order to set up n8n you'll need a test response in the selected survey. This allows you to select the individual values of each response in your workflow. If you have Formbricks running locally and you want to set up an app survey, you can use our [Demo App](/contributing/demo) to trigger a survey and submit a response.
![test trigger](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253356/image_ogjya8.jpg)
Next, click on Listen for event button.
![listen](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253388/image_pzerrp.jpg)
Then, go to the survey which you selected. Fill it out, and wait for the particular event to trigger (in this case it's `Response Finished`). Once the event is triggered you will see the response that you filled out in the survey.
![response](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253435/image_c0hyo9.jpg)
Now you have all the data you need at hand. The next steps depend on what you want to do with it. In this tutorial, we will send submissions to a discord channel:
1. Add Discord to your workflow: Click on the plus and search `Discord`.
![discord](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253513/image_hwld7h.jpg)
Fill in the `Webhook URL` and the `Content` that you want to receive in the respective discord channel. Next, click on `Execute Node` button to test the node.
![webhook](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253594/image_avxxkl.jpg)
Once the execution is successful, you'll receive the content in the discord channel.
![success](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253753/image_qlxvpv.jpg)
Voila! You have successfully enabled the n8n integration in your self-hosted Formbricks instance. Now you can follow the steps mentioned in the [Formbricks](/developer-docs/integrations/n8n) Integrations section to know more about the capabilities with Formbricks with n8n.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/integrations/notion.mdx
+47
View File
@@ -0,0 +1,47 @@
export const metadata = {
title: "Notion (On Premise)",
description: "Instantly populate a Notion database with survey data",
};
#### On Premise: Integrations
# Notion (On Premise)
The Notion integration allows you to automatically send responses to a Notion database of your choice.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/notion) to set it up.
</Note>
## Setup
Enabling the Notion Integration in a self-hosted environment requires a setup using Notion account and changing the environment variables of your Formbricks instance.
* Sign up for a [Notion](https://www.notion.so/) account, if you don't have one already.
* Go to the [my integrations](https://www.notion.so/my-integrations) page and click on **New integration**.
* Fill up the basic information like **Name**, **Logo** and click on **Submit**.
* Now, click on **Distribution** tab on the sidebar. A text will appear which will ask you to make the integration public. Click on that toggle button. A form will appear below the text.
* Now provide it the details such as requested. Under **Redirect URIs** field:
* If you are running formbricks locally, you can enter `http://localhost:3000/api/v1/integrations/notion/callback`.
* Or, you can enter `https://<your-public-facing-url>/api/v1/integrations/notion/callback`
* Once you've filled all the necessary details, click on **Submit**.
* Now just copy from the screen the **Client ID** and **Client secret** for your integration & add it to your **Formbricks environment variables** as in the docker compose file:
* `NOTION_OAUTH_CLIENT_ID` - OAuth Client ID
* `NOTION_OAUTH_CLIENT_SECRET` - OAuth Client Secret
Voila! You have successfully enabled the Notion integration in your self-hosted Formbricks instance. Now you can follow the steps mentioned in [Notion Integration with Formbricks](/developer-docs/integrations/notion) section to link your Notion with Formbricks.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/integrations/slack.mdx
+64
View File
@@ -0,0 +1,64 @@
export const metadata = {
title: "Slack (On Premise)",
description: "Send survey responses automatically to Slack workspace.",
};
#### On Premise: Integrations
# Slack (On Premise)
Send survey responses automatically to Slack workspace.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/slack) to set it up.
</Note>
## Setup
Enabling the Slack Integration in a self-hosted environment requires a setup using slack workspace account and changing the environment variables of your Formbricks instance.
<Note>Make sure your self-hosted Formbricks instance works with SSL as Slack requires it.</Note>
* Create a Slack workspace if you don't have one already.
* Go to the [Your apps](https://api.slack.com/apps) page and **Create New App**.
* Click on **From Scratch** and provide the **App Name** and select your workspace in **Pick a workspace to develop your app in:** dropdown. Click on **Create App**.
* Go to the **OAuth & Permissions** tab on the sidebar and add the following **Bot Token Scopes**:
* `channels:read`
* `groups:read`
* `chat:write`
* `chat:write.public`
* `chat:write.customize`
* Add the **Redirect URLs** under **OAuth & Permissions** tab. You can add the following URLs:
* If you are running formbricks locally, you can enter `https://localhost:3000/api/v1/integrations/slack/callback`.
* Or, you can enter `https://<your-public-facing-url>/api/v1/integrations/slack/callback`
* Now, click on **Install to Workspace** and **Allow** the permissions.
* Go to the **Basic Information** tab on the sidebar and copy the **Client ID** and **Client Secret**. Copy them & add it to your **Formbricks environment variables** as in the docker compose file:
* `SLACK_CLIENT_ID` - OAuth Client ID
* `SLACK_CLIENT_SECRET` - OAuth Client Secret
* Now, you need to enable the public distribution of your app. Go to the **Basic Information** tab and click on the **Manage distribution** button and click on the "Distribute App".
* Scroll down to the **Share your app with other workspaces** section, complete the checklist and click on the **Activate public distribution** button.
Voila! You have successfully enabled the Slack integration in your self-hosted Formbricks instance. Now you can follow the steps mentioned in the [Slack Integration](/developer-docs/integrations/slack) section to link a Slack workspace with Formbricks.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/integrations/zapier.mdx
+42
View File
@@ -0,0 +1,42 @@
export const metadata = {
title: "Zapier (On Premise)",
description: "Set up automations with your self-hosted Zapier instance.",
};
#### On Premise: Integrations
# Zapier (On Premise)
The Zapier integration allows you to create automations based on survey responses.
<Note>
If you are using Formbricks Cloud, you will need to configure this
integration differently. Please follow this guide
[here](/xm-and-surveys/core-features/integrations/zapier) to set it up.
</Note>
## Setup
Setup your Zap: Go to [zapier.com](https://zapier.com/) and create a new Zap. Search for “Formbricks” to get started:
![setup](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253827/image_dj64ty.jpg)
Then, choose the event you want to trigger the Zap on:
![trigger event](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738253929/image_p9kpxj_qxz2hw.jpg)
Connect Formbricks with Zapier: You have to connect Zapier with Formbricks via an API Key:
![connect](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738254011/image_fqjrtl.jpg)
![second](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738254061/image_apgw1y.jpg)
Now you need an API key. Please refer to the [API Key Setup](/developer-docs/rest-api##how-to-generate-an-api-key) page to learn how to create one.
Once you copied it in the newly opened Zapier window, you will be connected:
![last](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738254089/image_kzpadl.jpg)
Voila! You have successfully configured Zapier to work with your self-hosted Formbricks instance. Now, you can follow the steps mentioned in the [Zapier Integration](https://formbricks.com/docs/developer-docs/integrations/zapier) section to connect it with your Formbricks app and see it live.
Still struggling or something not working as expected? [Join our Github Discussions](https://github.com/formbricks/formbricks/discussions) and we'd be glad to assist you!
docs/self-hosting/configuration/oauth.mdx
+216
View File
@@ -0,0 +1,216 @@
---
title: OAuth
description: "OAuth for Formbricks"
icon: "key"
---
<Note>
Single Sign-On (SSO) functionality, including OAuth integrations with Google,
Microsoft Entra ID, Github and OpenID Connect, requires a valid Formbricks
Enterprise License.
</Note>
### Google OAuth
Integrating Google OAuth with your Formbricks instance allows users to log in using their Google credentials, ensuring a secure and streamlined user experience. This guide will walk you through the process of setting up Google OAuth for your Formbricks instance.
#### Requirements:
- A Google Cloud Platform (GCP) account.
- A Formbricks instance running and accessible.
#### Steps:
1. **Create a GCP Project**:
- Navigate to the [GCP Console](https://console.cloud.google.com/).
- From the projects list, select a project or create a new one.
2. **Setting up OAuth 2.0**:
- If the **APIs & services** page isn't already open, open the console left side menu and select **APIs & services**.
- On the left, click **Credentials**.
- Click **Create Credentials**, then select **OAuth client ID**.
3. **Configure OAuth Consent Screen**:
- If this is your first time creating a client ID, configure your consent screen by clicking **Consent Screen**.
- Fill in the necessary details and under **Authorized domains**, add the domain where your Formbricks instance is hosted.
4. **Create OAuth 2.0 Client IDs**:
- Select the application type **Web application** for your project and enter any additional information required.
- Ensure to specify authorized JavaScript origins and authorized redirect URIs.
```{{ Redirect & Origin URLs
Authorized JavaScript origins: {WEBAPP_URL}
Authorized redirect URIs: {WEBAPP_URL}/api/auth/callback/google
```
- **Update Environment Variables in Docker**:
- To integrate the Google OAuth, you have two options: either update the environment variables in the docker-compose file or directly add them to the running container.
- In your Docker setup directory, open the `.env` file, and add or update the following lines with the `Client ID` and `Client Secret` obtained from Google Cloud Platform:
- Alternatively, you can add the environment variables directly to the running container using the following commands (replace `container_id` with your actual Docker container ID):
```sh Shell commands
docker exec -it container_id /bin/bash
export GOOGLE_CLIENT_ID=your-client-id-here
export GOOGLE_CLIENT_SECRET=your-client-secret-here
exit
```
```sh env file
GOOGLE_CLIENT_ID=your-client-id-here
GOOGLE_CLIENT_SECRET=your-client-secret-here
```
1. **Restart Your Formbricks Instance**:
- **Note:** Restarting your Docker containers may cause a brief period of downtime. Plan accordingly.
- Once the environment variables have been updated, it's crucial to restart your Docker containers to apply the changes. This ensures that your Formbricks instance can utilize the new Google OAuth configuration for user authentication. Here's how you can do it:
- Navigate to your Docker setup directory where your `docker-compose.yml` file is located.
- Run the following command to bring down your current Docker containers and then bring them back up with the updated environment configuration:
### Microsoft Entra ID (Azure Active Directory) SSO OAuth
Do you have a Microsoft Entra ID Tenant? Integrate it with your Formbricks instance to allow users to log in using their existing Microsoft credentials. This guide will walk you through the process of setting up an Application Registration for your Formbricks instance.
#### Requirements
- A Microsoft Entra ID Tenant populated with users. [Create a tenant as per Microsoft's documentation](https://learn.microsoft.com/en-us/entra/fundamentals/create-new-tenant).
- A Formbricks instance running and accessible.
- The callback URI for your Formbricks instance: `{WEBAPP_URL}/api/auth/callback/azure-ad`
#### Creating an App Registration
- Login to the [Microsoft Entra admin center](https://entra.microsoft.com/).
- Go to **Applications** > **App registrations** in the left menu.
![first](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250153/image_tobdth.jpg)
- Click the **New registration** button at the top.
![second](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250228/image_dmz75t.jpg)
- Name your application something descriptive, such as `Formbricks SSO`.
![third](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250292/image_rooa3w.jpg)
- If you have multiple tenants/organizations, choose the appropriate **Supported account types** option. Otherwise, leave the default option for _Single Tenant_.
![fourth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250542/image_nyndzo.jpg)
- Under **Redirect URI**, select **Web** for the platform and paste your Formbricks callback URI (see Requirements above).
![fifth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250776/image_s3pgb6.jpg)
- Click **Register** to create the App registration. You will be redirected to your new app's _Overview_ page after it is created.
- On the _Overview_ page, under **Essentials**:
- Copy the entry for **Application (client) ID** to populate the `AZUREAD_CLIENT_ID` variable.
- Copy the entry for **Directory (tenant) ID** to populate the `AZUREAD_TENANT_ID` variable.
![sixth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250876/image_dj2vi5.jpg)
- From your App registration's _Overview_ page, go to **Manage** > **Certificates & secrets**.
![seventh](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250913/image_p4zknw.jpg)
- Make sure you have the **Client secrets** tab active, and click **New client secret**.
![eighth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738250973/image_kyjray.jpg)
- Enter a **Description**, set an **Expires** period, then click **Add**.
<Note>
You will need to create a new client secret using these steps whenever your
chosen expiry period ends.
</Note>
![ninth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738251467/image_bkirq4.jpg)
- Copy the entry under **Value** to populate the `AZUREAD_CLIENT_SECRET` variable.
<Note>
Microsoft will only show this value to you immediately after creation, and you
will not be able to access it again. If you lose it, simply start from step 9
to create a new secret.
</Note>
![tenth](https://res.cloudinary.com/dwdb9tvii/image/upload/v1738251234/image_jen6tp.jpg)
- Update these environment variables in your `docker-compose.yml` or pass it like your other environment variables to the Formbricks container.
<Note>
You must wrap the `AZUREAD_CLIENT_SECRET` value in double quotes (e.g.,
"THis~iS4faKe.53CreTvALu3"`) to prevent issues with special characters.
</Note>
An example `.env` for Microsoft Entra ID in Formbricks would look like:
````yml Formbricks Env for Microsoft Entra ID SSO
AZUREAD_CLIENT_ID=a25cadbd-f049-4690-ada3-56a163a72f4c
AZUREAD_TENANT_ID=2746c29a-a3a6-4ea1-8762-37816d4b7885
AZUREAD_CLIENT_SECRET="THis~iS4faKe.53CreTvALu3"
```
- Restart your Formbricks instance.
- You're all set! Users can now sign up & log in using their Microsoft credentials associated with your Entra ID Tenant.
## OpenID Configuration
Integrating your own OIDC (OpenID Connect) instance with your Formbricks instance allows users to log in using their OIDC credentials, ensuring a secure and streamlined user experience. Please follow the steps below to set up OIDC for your Formbricks instance.
- Configure your OIDC provider & get the following variables:
- `OIDC_CLIENT_ID`
- `OIDC_CLIENT_SECRET`
- `OIDC_ISSUER`
- `OIDC_SIGNING_ALGORITHM`
<Note>
Make sure the Redirect URI for your OIDC Client is set to `{WEBAPP_URL}
/api/auth/callback/openid`.
</Note>
- Update these environment variables in your `docker-compose.yml` or pass it directly to the running container.
An example configuration for a FusionAuth OpenID Connect in Formbricks would look like:
```yml Formbricks Env for FusionAuth OIDC
OIDC_CLIENT_ID=59cada54-56d4-4aa8-a5e7-5823bbe0e5b7
OIDC_CLIENT_SECRET=4f4dwP0ZoOAqMW8fM9290A7uIS3E8Xg29xe1umhlB_s
OIDC_ISSUER=http://localhost:9011 OIDC_DISPLAY_NAME=FusionAuth
OIDC_SIGNING_ALGORITHM=HS256
```
- Set an environment variable `OIDC_DISPLAY_NAME` to the display name of your OIDC provider.
- Restart your Formbricks instance.
- You're all set! Users can now sign up & log in using their OIDC credentials.
````
docs/self-hosting/overview.mdx
+56
View File
@@ -0,0 +1,56 @@
---
title: "Self-Hosting"
description: "Learn how to self-host Formbricks."
icon: "server"
---
### System Requirements
<Info>
**Minimum Setup**: 1 vCPU, 2 GB RAM, 8 GB SSD.
</Info>
<Info>
**HTTPS Required**: Ensure your server runs with a valid HTTPS certificate.
</Info>
#### **Self-Hosting Options**
* [**One-Click Setup**](/self-hosting/setup/one-click)**:** Set up Formbricks on Ubuntu in minutes with our shell script.
* [**Docker Setup**](/self-hosting/setup/docker)**:** Use our pre-built Docker image for an effortless start.
* [**Migration Guide**](/self-hosting/setup/migration)**:** Upgrade your existing Formbricks instance smoothly.
* [**Configuration**](/self-hosting/configuration)**:** Customize your setup with advanced configurations.
* [**Integrations**](/self-hosting/configuration/integrations)**:** Connect Formbricks to third-party tools.
* [**Licensing**](/self-hosting/advanced/license)**:**  Learn more about our AGPL Formbricks Core and its open-source license & Unlock advanced features tailored for larger teams and enterprises with the EE License.
### **Hosting Options**
* **Cloud Hosting:** Hassle-free managed deployment at [app.formbricks.com](https://app.formbricks.com).
* **Self-Hosting Free:** Perfect for personal use or small projects.
* **Self-Hosting with EE License:** Unlock advanced features for large teams or enterprises.
### **Licensing Options Comparison**:
For Self Hosting, our core product is free however certain advanced features are a part of our Enterprise License offering. Please refer this table to understand if you want the features that are a part of it and then we’ll reach out to you!
| **Feature** | Cloud Hosting | Self-Hosting Free | Self-Hosting EE License |
| ----------------------- | -------------------------- | ----------------- | ----------------------- |
| Setup & Maintenance | Managed | DIY | DIY |
| Advanced Functionality | Full (Optional Paid plans) | Most of them | All Advanced Features |
| Support & Updates | Included | Community | Prioritized |
| Price | Subscription | Free | Fixed Per month |
| Customization & Control | Limited | Moderate | Full |
For licensing queries, contact us at [**hola@formbricks.com**]().
Formbricks is designed to be intuitive and accessible, ensuring an easy setup no matter which option you choose. Start using Formbricks today and take your surveys to the next level!
**Need Help?**
Join the conversation on [**GitHub Discussions**](https://github.com/formbricks/formbricks/discussions).
docs/self-hosting/setup/cluster-setup.mdx
+60
View File
@@ -0,0 +1,60 @@
---
title: 'Cluster Setup'
description: "How to set up Formbricks in a cluster"
icon: "circle-nodes"
---
<Note>
Running Formbricks in a multi-instance cluster configuration is an Enterprise Edition feature and requires an enterprise license key.
</Note>
## Overview
Running Formbricks as a cluster of multiple instances offers several key advantages:
* **High Availability**: Ensure your surveys remain accessible even if some instances fail
* **Load Distribution**: Handle higher traffic by distributing requests across multiple instances
* **Scalability**: Easily scale horizontally by adding more instances as your needs grow
* **Zero-Downtime Updates**: Rolling updates without service interruption
## Requirements
To run Formbricks in a cluster setup, you'll need:
* Enterprise Edition license key
* Shared PostgreSQL database
* Shared Redis cache for session management and caching
* Load balancer to distribute traffic
## Redis Configuration
<Note>
Redis integration is an Enterprise Edition feature and requires an enterprise license key.
</Note>
Configure Redis by adding the following environment variables to your instances:
```sh env
REDIS_URL=redis://your-redis-host:6379
REDIS_HTTP_URL=http://your-redis-host:8000
```
## Coming Soon
We're working on comprehensive Kubernetes deployment instructions to make cluster setup even easier. This will include:
* Kubernetes manifests
* Helm charts
* Detailed scaling configurations
* Production-ready deployment examples
Stay tuned for updates.
docs/self-hosting/setup/docker.mdx
+149
View File
@@ -0,0 +1,149 @@
---
title: "Docker Setup"
description: "Set up Formbricks quickly using our ready-to-use Docker image."
icon: "docker"
---
The image is pre-built and requires minimal setup—just download it and start the container.
### Requirements
Make sure Docker and Docker Compose are installed on your system. These are usually included in tools like Docker Desktop and Rancher Desktop.
<Note>
`docker compose` without the hyphen is now the primary method of using docker-compose, according to the Docker documentation.
</Note>
## Start
* **Create a New Directory for Formbricks**
Open a terminal and run the following commands to create and enter a new directory for Formbricks:
```bash
mkdir formbricks-quickstart && cd formbricks-quickstart
```
* **Download the Docker-Compose File**
Get the docker-compose file from the Formbricks repository by running:
```bash
curl -o docker-compose.yml https://raw.githubusercontent.com/formbricks/formbricks/main/docker/docker-compose.yml
```
* **Generate NextAuth Secret**
You need a NextAuth secret for session signing and encryption. Run the command below to generate a random string using `openssl` and automatically insert it into the `docker-compose.yml` file:
```bash
sed -i "/NEXTAUTH_SECRET:$/s/NEXTAUTH_SECRET:.*/NEXTAUTH_SECRET: $(openssl rand -hex 32)/" docker-compose.yml
```
* **Generate Encryption Key**
Next, you need to generate an Encryption Key. This will be used for authenticating and verifying 2 Factor Authentication. The `sed` command below generates a random string using `openssl`, then replaces the `ENCRYPTION_KEY:` placeholder in the `docker-compose.yml` file with this generated secret:
```bash
sed -i "/ENCRYPTION_KEY:$/s/ENCRYPTION_KEY:.*/ENCRYPTION_KEY: $(openssl rand -hex 32)/" docker-compose.yml
```
* **Generate Cron Secret**
You require a Cron secret to secure API access for running cron jobs. Run the command below to generate a random string using `openssl` and automatically insert it into the `docker-compose.yml` file:
```bash
sed -i "/CRON_SECRET:$/s/CRON_SECRET:.*/CRON_SECRET: $(openssl rand -hex 32)/" docker-compose.yml
```
* **Start the Docker Setup**
Now, you’re ready to run Formbricks with Docker. Use the command below to start Formbricks along with a PostgreSQL database using Docker Compose:
```bash
docker compose up -d
```
The `-d` flag runs the containers in the background, so they keep running even after you close the terminal.
* **Open Formbricks in Your Browser**
Once the setup is running, open [**http://localhost:3000**](http://localhost:3000) in your browser to access Formbricks. The first time you visit, you'll see a setup wizard. Follow the steps to create your first user and start using Formbricks.
## Update
Please take a look at our [migration guide](/migration-guide) for version specific steps to update Formbricks.
* Pull the latest Formbricks image
```bash
docker compose pull
```
* Stop the Formbricks stack
```bash
docker compose down
```
* Re-start the Formbricks stack with the updated image
```bash
docker compose up -d
```
## Debug
If you encounter any issues, you can check the logs of the container with this command:
```bash
docker compose logs -f
```
In an ideal case, you should see this:
```bash
[+] Running 9/16
⠹ formbricks 15 layers [⣿⣤⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀] 29.78MB/47.76MB Pulling 13.3s
✔ 7264a8db6415 Already exists 0.0s
⠋ 751194035c36 Downloading [===============================> ] 29.78MB/47.76... 8.1s
✔ eff5dce73b38 Download complete 1.7s
✔ c8ce5be43019 Download complete 1.2s
✔ a2f33c630af5 Download complete 5.1s
✔ e3b64e437860 Download complete 3.3s
✔ a6551ac5f976 Download complete 4.9s
✔ 4f4fb700ef54 Download complete 6.0s
✔ 22163889e16b Download complete 6.7s
✔ dc647bb9eb13 Download complete 7.8s
⠋ 49c2ad494720 Waiting 8.1s
⠋ 5c797a842dcb Waiting 8.1s
⠋ 1f231213db04 Waiting 8.1s
⠋ e407294bdcda Waiting 8.1s
⠋ 6fd8358dca47 Pulling fs layer 8.1s
[+] Running 2/2
✔ Container formbricks-quickstart-postgres-1 Created 0.0s
✔ Container formbricks-quickstart-formbricks-1 Created 0.0s
```
And at the tail of the output, you should see this:
```bash
formbricks-quickstart-formbricks-1 | All migrations have been successfully applied.
formbricks-quickstart-formbricks-1 |
formbricks-quickstart-formbricks-1 | - info Loaded env from /home/nextjs/apps/web/.env
formbricks-quickstart-formbricks-1 | Listening on port 3000 url: http://<random-string>:3000
```
You can close the logs again by hitting `CTRL + C`.
## [](https://formbricks.com/docs/self-hosting/docker#customizing-environment-variables)
<Note>
**Customizing environment variables**
To edit any of the available environment variables, check out our [Configure](/configuration) section!
</Note>
If you have any questions or require help, feel free to reach out to us on [**GitHub Discussions**](https://github.com/formbricks/formbricks/discussions). 😃[
](https://formbricks.com/docs/developer-docs/rest-api)
docs/self-hosting/setup/one-click.mdx
+346
View File
@@ -0,0 +1,346 @@
---
title: "One-Click Setup"
description: "How to set up Formbricks instance with a one-click script"
icon: "rocket"
---
<Note>
This only works with an Ubuntu machine, so ensure the underlying OS is verified beforehand!
</Note>
If you’re looking to quickly set up a production instance of Formbricks on an Ubuntu server, this guide is for you. Using a convenient shell script, you can install everything—including Docker, Postgres DB, and an SSL certificate—in just a few steps. The script takes care of all the dependencies and configuration for your server, making the process smooth and simple.
<Note>
This setup uses **Traefik** as a **reverse proxy**, essential for directing incoming traffic to the correct container and enabling secure internet access to Formbricks. Traefik is chosen for its simplicity and automatic SSL management via Let’s Encrypt.
</Note>
For other operating systems or a more customized installation, please refer to the advanced installation guide with [Docker](/self-hosting/docker).
### Requirements
* An Ubuntu Virtual Machine with SSH access.
* A custom domain with an **A record** pointing to your server.
* Ports **80** and **443** are open in your VM's Security Group, allowing Traefik to create an SSL certificate.
### Deployment
Run this command in your terminal:
```bash
curl -fsSL https://raw.githubusercontent.com/formbricks/formbricks/main/docker/formbricks.sh -o formbricks.sh && chmod +x formbricks.sh && ./formbricks.sh install
```
### Script Prompts
During installation, the script will prompt you to provide some details:
* **Overwriting Docker GPG Keys**:
If Docker GPG keys already exist, the script will ask whether you want to overwrite them.
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N)
```
* **Domain Name**:
Enter the domain name where you’ll host Formbricks. The domain will be used to generate an SSL certificate. Do not include the protocol (http/https).
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
```
* **HTTPS Certificate Setup**:
The script will ask if you’d like to create an HTTPS certificate for your domain. Enter `Y` to proceed (highly recommended for secure access).
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
```
* **DNS Setup Prompt**: Ensure that your domain's DNS is correctly configured and ports 80 and 443 are open. Confirm this by entering `Y`. This step is crucial for proper SSL certificate issuance and secure server access.
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
Y
🔗 Please make sure that the domain points to the server's IP address and that ports 80 & 443 are open in your server's firewall. Is everything set up? [Y/n]
```
* **Email Address for SSL Certificate**:
Provide an email address to register the SSL certificate. Notifications regarding the certificate will be sent to this address.
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
Y
🔗 Please make sure that the domain points to the server's IP address and that ports 80 & 443 are open in your server's firewall. Is everything set up? [Y/n]
Y
💡 Please enter your email address for the SSL certificate:
```
* **Enforce HTTPS with HSTS**:
Enabling HTTP Strict Transport Security (HSTS) ensures all communication with your server is encrypted. It’s a recommended best practice. Enter `Y` to enforce HTTPS.
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
Y
🔗 Please make sure that the domain points to the server's IP address and that ports 80 & 443 are open in your server's firewall. Is everything set up? [Y/n]
Y
💡 Please enter your email address for the SSL certificate:
docs@formbricks.com
🔗 Do you want to enforce HTTPS (HSTS)? [Y/n]
```
* **Email Service Setup Prompt**: The script will ask if you want to set up the email service. Enter `Y` to proceed.(default is `N`). You can skip this step if you don't want to set up the email service. You will still be able to use Formbricks without setting up the email service.
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
Y
🔗 Please make sure that the domain points to the server's IP address and that ports 80 & 443 are open in your server's firewall. Is everything set up? [Y/n]
Y
💡 Please enter your email address for the SSL certificate:
docs@formbricks.com
🔗 Do you want to enforce HTTPS (HSTS)? [Y/n]
Y
🚗 Configuring Traefik...
💡 Created traefik.yaml and traefik-dynamic.yaml file.
💡 Created acme.json file with correct permissions.
📧 Do you want to set up the email service? You will need SMTP credentials for the same! [y/N]
```
**That's it**! After running the command and providing the required information, visit the domain name you entered, and you should see the Formbricks home wizard!
```
🚀 Executing default step of installing Formbricks
🧱 Welcome to the Formbricks Setup Script
🛸 Fasten your seatbelts! We're setting up your Formbricks environment on your Ubuntu 24.04 LTS server.
🧹 Time to sweep away any old Docker installations.
🔄 Updating your package list.
📦 Installing the necessary dependencies.
🔑 Adding Docker's official GPG key and setting up the stable repository.
File '/etc/apt/keyrings/docker.gpg' exists. Overwrite? (y/N) y
🔄 Updating your package list again.
🐳 Installing Docker.
🚀 Testing your Docker installation.
🎉 Docker is installed!
🐳 Adding your user to the Docker group to avoid using sudo with docker commands.
🎉 Hooray! Docker is all set and ready to go. You're now ready to run your Formbricks instance!
📁 Created Formbricks Quickstart directory at ./formbricks.
🔗 Please enter your domain name for the SSL certificate (🚨 do NOT enter the protocol (http/https/etc)):
my.hosted.url.com
🔗 Do you want us to set up an HTTPS certificate for you? [Y/n]
Y
🔗 Please make sure that the domain points to the server's IP address and that ports 80 & 443 are open in your server's firewall. Is everything set up? [Y/n]
Y
💡 Please enter your email address for the SSL certificate:
docs@formbricks.com
🔗 Do you want to enforce HTTPS (HSTS)? [Y/n]
Y
🚗 Configuring Traefik...
💡 Created traefik.yaml and traefik-dynamic.yaml file.
💡 Created acme.json file with correct permissions.
📧 Do you want to set up the email service? You will need SMTP credentials for the same! [y/N] N
📥 Downloading docker-compose.yml from Formbricks GitHub repository...
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 6632 100 6632 0 0 24280 0 --:--:-- --:--:-- --:--:-- 24382
🚙 Updating docker-compose.yml with your custom inputs...
🚗 NEXTAUTH_SECRET updated successfully!
🚗 ENCRYPTION_KEY updated successfully!
🚗 CRON_SECRET updated successfully!
[+] Running 4/4
✔ Network formbricks_default Created 0.2s
✔ Container formbricks-postgres-1 Started 1.0s
✔ Container formbricks-formbricks-1 Started 1.6s
✔ Container traefik Started 2.8s
🔗 To edit more variables and deeper config, go to the formbricks/docker-compose.yml, edit the file, and restart the container!
🚨 Make sure you have set up the DNS records as well as inbound rules for the domain name and IP address of this instance.
🎉 All done! Please setup your Formbricks instance by visiting your domain at https://my.hosted.url.com. You can check the status of Formbricks & Traefik with 'cd formbricks && sudo docker compose ps.'
```
## Update
To update Formbricks, simply run the following command:
```
./formbricks.sh update
```
The script will automatically pull the latest version of Formbricks from GitHub Container Registry and restart the containers.
## Stop
To stop Formbricks, simply run the following command:
```
./formbricks.sh stop
```
The script will automatically stop all the Formbricks related containers and brings the entire stack down.
## Restart
To restart Formbricks, simply run the following command:
```
./formbricks.sh restart
```
The script will automatically restart all the Formbricks related containers and brings the entire stack up with the previous configuration.
## Uninstall
To uninstall Formbricks, simply run the following command, but keep in mind that this will delete all your data!
```
./formbricks.sh uninstall
```
The script will automatically stop all the Formbricks related containers, remove the Formbricks directory, and delete the Docker network.
## Debug
If you encounter any issues, you can check the logs of the containers with:
```
./formbricks.sh logs
```
## Troubleshooting
If you encounter any issues, consider the following steps:
* **Inbound Rules**: Make sure you have added inbound rules for Port 80 and 443 in your VM's Security Group.
* **A Record**: Verify that you have set up an A record for your domain, pointing to your VM's IP address.
* **Check Docker Instances**: Run `docker ps` to check the status of the Docker instances.
* **Check Formbricks Logs**: Run `cd formbricks && docker compose logs` to check the logs of the Formbricks stack.
If you have any questions or require help, feel free to reach out to us on [**GitHub Discussions**](https://github.com/formbricks/formbricks/discussions). 😃[
](https://formbricks.com/docs/developer-docs/rest-api)