# Destinations

Destinations are where flows deliver. Email is built in and needs no setup. Slack, Microsoft Teams, Discord, Google Chat, Mattermost, Telegram and webhooks are connected once on the Destinations page, and then any flow of the workspace can use them.

**On this page you will learn**

- How to connect each destination, step by step
- What each message looks like when it arrives
- Who can see destination addresses
- Which addresses are allowed and how long Formpik waits
- What happens when a delivery fails
- How to get an email when something breaks

## All destinations

| Destination | Flow step | What you need | Address |
| --- | --- | --- | --- |
| Email | Send email, Reply to sender | Nothing, it is built in | Email addresses |
| Slack | Post to Slack | Post a message in a channel through an incoming webhook. | `https://hooks.slack.com/...` |
| Microsoft Teams | Post to Teams | Post a card in a channel through a Teams workflow webhook. | Any public https address |
| Discord | Post to Discord | Send a message to a channel with a Discord webhook. | `https://discord.com/api/webhooks/...` |
| Google Chat | Post to Google Chat | Post a message in a Google Chat space through an incoming webhook. | `https://chat.googleapis.com/...` |
| Mattermost | Post to Mattermost | Post a message in a Mattermost channel through an incoming webhook. | Any public https address |
| Telegram | Send to Telegram | Send a message to a Telegram chat, group or channel through your own bot. | `https://api.telegram.org/bot...` |
| Webhook | Send webhook | Send each submission as JSON to your CRM, backend or any URL. | Any public https address |

Your plan sets how many destinations a workspace can connect. Email steps do not count. See [Plans and limits](https://formpik.com/docs/plans).

## Email

Two flow steps send email. Neither needs a destination.

- **Send email** mails your team. Fill in **To** (several addresses separated by commas), an optional **Cc**, an optional **Reply to**, the subject and the message. Put `{{email}}` in Reply to so your team can answer the sender straight from their inbox. It is sent from **your workspace name via Formpik**.
- **Reply to sender** sends an automatic reply to the visitor. It goes to one address only, is sent from your workspace name, and leaves out long free text answers (long text, web addresses, files and anything over 80 characters) so the form cannot be used to send spam.
- An address a visitor typed gets at most 3 emails a day from your workspace. That covers Reply to sender and any Send email whose To uses a variable. Further steps are skipped, not failed.
- Without a subject, the email uses `New submission: {form name}`. `{{submission.all_fields}}` in the message lists every answer.

*A Send email step as it arrives*

```
From: Acme via Formpik
To: sales@yourcompany.com
Reply-To: jane@example.com
Subject: New lead: Jane Cooper

Jane Cooper sent the Contact form.

Full name: Jane Cooper
Email: jane@example.com
What can we help with?: Sales
Message: We would like a new website for our team. Could we talk next week?
Project brief: brief.pdf

Acme · sent with Formpik
```

The message is sent as plain text and as a simple styled card with your workspace name underneath. Addresses that bounced or reported spam before are skipped, and the step says so.

## Slack

1. **Create the webhook in Slack**

   In Slack, create an app with Incoming Webhooks turned on and copy the URL for the channel.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Slack. Give it a name you will recognize in flows, fill in the channel (for example `#sales-leads`) and paste the incoming webhook url.
3. **Use it in a flow**

   Add a **Post to Slack** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

The address must start with `https://hooks.slack.com/`. Formpik posts your message as a section, the answers as fields (up to 40) and a small footer with the form name:

*Body Formpik posts to Slack*

```json
{
  "text": "New Sales request from Jane Cooper",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "New Sales request from Jane Cooper"
      }
    },
    {
      "type": "section",
      "fields": [
        {
          "type": "mrkdwn",
          "text": "*Full name*\nJane Cooper"
        },
        {
          "type": "mrkdwn",
          "text": "*Email*\njane@example.com"
        },
        {
          "type": "mrkdwn",
          "text": "*What can we help with?*\nSales"
        },
        {
          "type": "mrkdwn",
          "text": "*Message*\nWe would like a new website for our team. Could we talk next week?"
        },
        {
          "type": "mrkdwn",
          "text": "*Project brief*\nbrief.pdf"
        }
      ]
    },
    {
      "type": "context",
      "elements": [
        {
          "type": "mrkdwn",
          "text": "Formpik · Contact"
        }
      ]
    }
  ]
}
```

## Microsoft Teams

1. **Create the webhook in Microsoft Teams**

   In Teams, add the "Post to a channel when a webhook request is received" workflow and copy its URL.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Microsoft Teams. Give it a name you will recognize in flows, fill in the channel (for example `Support › Escalations`) and paste the workflow webhook url.
3. **Use it in a flow**

   Add a **Post to Teams** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

Formpik posts an Adaptive Card: your message in bold, then the answers as facts (up to 30):

*Body Formpik posts to Teams*

```json
{
  "type": "message",
  "attachments": [
    {
      "contentType": "application/vnd.microsoft.card.adaptive",
      "content": {
        "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
        "type": "AdaptiveCard",
        "version": "1.4",
        "body": [
          {
            "type": "TextBlock",
            "text": "New Sales request from Jane Cooper",
            "wrap": true,
            "weight": "Bolder"
          },
          {
            "type": "FactSet",
            "facts": [
              {
                "title": "Full name",
                "value": "Jane Cooper"
              },
              {
                "title": "Email",
                "value": "jane@example.com"
              },
              {
                "title": "What can we help with?",
                "value": "Sales"
              },
              {
                "title": "Message",
                "value": "We would like a new website for our team. Could we talk next week?"
              },
              {
                "title": "Project brief",
                "value": "brief.pdf"
              }
            ]
          }
        ]
      }
    }
  ]
}
```

## Discord

1. **Create the webhook in Discord**

   In Discord, open the channel settings, then Integrations, Webhooks, New Webhook, and copy its URL.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Discord. Give it a name you will recognize in flows, fill in the channel (for example `#community`) and paste the webhook url.
3. **Use it in a flow**

   Add a **Post to Discord** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

The address must start with `https://discord.com/api/webhooks/` or `https://discordapp.com/api/webhooks/`. Formpik posts your message with the answers in an embed (up to 25 fields). Mentions are switched off, so an answer like `@everyone` never pings your server:

*Body Formpik posts to Discord*

```json
{
  "content": "New Sales request from Jane Cooper",
  "allowed_mentions": {
    "parse": []
  },
  "embeds": [
    {
      "title": "Contact",
      "color": 2118872,
      "fields": [
        {
          "name": "Full name",
          "value": "Jane Cooper",
          "inline": true
        },
        {
          "name": "Email",
          "value": "jane@example.com",
          "inline": true
        },
        {
          "name": "What can we help with?",
          "value": "Sales",
          "inline": true
        },
        {
          "name": "Message",
          "value": "We would like a new website for our team. Could we talk next week?",
          "inline": false
        },
        {
          "name": "Project brief",
          "value": "brief.pdf",
          "inline": true
        }
      ]
    }
  ]
}
```

## Google Chat

1. **Create the webhook in Google Chat**

   In Google Chat, open the space, then Apps and integrations, Webhooks, Add webhook, and copy its URL.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Google Chat. Give it a name you will recognize in flows, fill in the space (for example `Sales leads`) and paste the webhook url.
3. **Use it in a flow**

   Add a **Post to Google Chat** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

The address must start with `https://chat.googleapis.com/`. Formpik posts your message as text, with each answer on its own line under it in bold when Include every answer is on:

*Body Formpik posts to Google Chat*

```json
{
  "text": "New Sales request from Jane Cooper\n\n*Full name*: Jane Cooper\n*Email*: jane@example.com\n*What can we help with?*: Sales\n*Message*: We would like a new website for our team. Could we talk next week?\n*Project brief*: brief.pdf"
}
```

## Mattermost

1. **Create the webhook in Mattermost**

   In Mattermost, open Integrations, Incoming Webhooks, Add Incoming Webhook, pick the channel and copy the URL.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Mattermost. Give it a name you will recognize in flows, fill in the channel (for example `~sales-leads`) and paste the incoming webhook url.
3. **Use it in a flow**

   Add a **Post to Mattermost** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

Your Mattermost server can be anywhere on the public internet, so any public `https` address works. Formpik posts your message as Markdown, with the answers under it, and signs it as Formpik:

*Body Formpik posts to Mattermost*

```json
{
  "text": "New Sales request from Jane Cooper\n\n**Full name**: Jane Cooper\n**Email**: jane@example.com\n**What can we help with?**: Sales\n**Message**: We would like a new website for our team. Could we talk next week?\n**Project brief**: brief.pdf",
  "username": "Formpik"
}
```

## Telegram

1. **Create the webhook in Telegram**

   Message `@BotFather` in Telegram, send `/newbot` and copy the token it gives you. Add the bot to your group or channel (as an admin for channels), then find the chat ID, such as `-1001234567890`, or use `@yourchannel` for a public channel. The address is `https://api.telegram.org/bot`, then the token, then `/sendMessage`.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Telegram. Give it a name you will recognize in flows, fill in the chat id (for example `-1001234567890`) and paste the bot api url.
3. **Use it in a flow**

   Add a **Send to Telegram** step and pick the destination under **Channel**. Write the message with variables such as `{{full_name}}`, and turn on **Include every answer** to add the answers under it.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

The bot token sits inside the address, so it is hidden from everyone below admin like every other destination address. Formpik sends plain text, so nothing in an answer can change the formatting, and link previews are switched off:

*Body Formpik posts to Telegram*

```json
{
  "chat_id": "-1001234567890",
  "text": "New Sales request from Jane Cooper\n\nFull name: Jane Cooper\nEmail: jane@example.com\nWhat can we help with?: Sales\nMessage: We would like a new website for our team. Could we talk next week?\nProject brief: brief.pdf",
  "disable_web_page_preview": true
}
```

## Webhooks

1. **Get your address**

   Use any public `https` address that accepts a JSON POST: your backend, your CRM's intake address, or a catch hook in Zapier or Make.
2. **Connect it in Formpik**

   Open **Destinations** and choose **Connect** (or **Add another**) on Webhook. Give it a name you will recognize in flows, fill in the description (for example `CRM lead intake`) and paste the endpoint url.
3. **Use it in a flow**

   Add a **Send webhook** step and pick the destination under **Send to**.
4. **Send a real submission**

   Test runs in the editor only simulate the step. Post one real submission and check the run in the inbox.

Each webhook gets its own signing secret when you connect it. Choose **Edit** on the webhook on the Destinations page to copy it. Every delivery is signed with it, see [Webhooks](https://formpik.com/docs/webhooks) for the payload, the headers and how to check the signature.

## Who can see addresses

A webhook address works like a password: whoever has it can post to your Slack channel or your backend. So:

- Owners and admins see every address in full, and the signing secret of each webhook.
- Editors and viewers see only the start, such as `https://hooks.slack.com/...`, and no signing secret.
- An editor can still rename a destination or change its channel. When the hidden address is saved unchanged, Formpik keeps the real one. Pasting a new address replaces it.
- Editors and up can connect destinations and use them in flows.

## Address rules and timeout

- Addresses must use `https`. Plain `http` is refused with "Use an https address."
- Addresses may not contain a user name or password.
- Private networks are refused: `localhost`, names ending in `.local` or `.internal`, and private, loopback and link-local IP addresses such as `10.0.0.5`, `192.168.1.20` or `127.0.0.1`. To reach a server on your own network, put a public https address in front of it.
- Formpik waits up to 10 seconds for an answer. Any 2xx status counts as delivered.
- Redirects are not followed. A 3xx answer counts as a failure, so give the final address.

## When a delivery fails

Each step reports exactly what happened in the run history of the submission:

| What you see on the step | What it means |
| --- | --- |
| Posted to #sales-leads, or Sent to api.yourcompany.com | Delivered. The details show the status and the time, such as Answered HTTP 200 in 143 ms. |
| ... did not accept it, or ... answered with an error | The destination answered with a status outside 2xx. The details show the status and the start of its answer. |
| No answer within 10 seconds | The destination did not answer in time. |
| Could not reach the destination | The address could not be reached at all, for example a typo in the domain. |
| Destination is not connected | The destination used by the step was removed. Pick another one in the flow. |
| Email was not sent | The email could not go out. The details say why, such as an invalid address or every recipient being blocked. |

- A failed step stops the steps after it on the same path. Other flows of the form still run.
- The submission is marked `Needs attention` in the inbox.
- Failed deliveries are not retried on their own. Fix the cause, then open the submission and choose Run flows again. That runs every live flow of the form again for real, so every email, chat message and webhook of those flows goes out again.
- Flows that use a removed destination show a warning on that step and cannot go live until you pick another one.

### Email alerts

With **Delivery problems** on under the workspace's **Settings**, Notifications (on by default), owners and admins get an email when a live run fails. It names the form, the flows and the first failed step with its reason, and links to the submission. To avoid a flood, a workspace sends at most 6 of these alerts an hour.

## Common questions

### Why did my Slack channel get nothing after a test in the editor?

Test runs in the flow editor and test submissions from the form builder only simulate deliveries. Send one real submission to the endpoint to post for real.

### Can several flows use the same destination?

Yes. A destination is connected once per workspace and any flow can pick it.

### I renamed my Slack channel and posts stopped. Why?

Slack ties an incoming webhook to a channel. Create a new webhook for the channel in Slack, then edit the destination and paste the new address.

### Can I send to an http address or a server on my office network?

No. Destinations must be public https addresses, so a flow can never be pointed at something only Formpik’s servers can reach.

### Who gets the delivery problem emails?

The owner and the admins of the workspace. Owners and admins can turn them off under Settings, Notifications.

- [Webhooks](https://formpik.com/docs/webhooks): The payload, the headers and the signature.
- [Variables and templates](https://formpik.com/docs/templates): Put answers and AI results in your messages.
- [Submissions inbox](https://formpik.com/docs/submissions): Read run histories and run flows again.
- [Flows](https://formpik.com/docs/flows): Every step that can deliver to a destination.

---

Source: https://formpik.com/docs/destinations
