---
title: "Typeform Connector"
description: "Vollständiger Leitfaden zur Typeform-Integration für die Synchronisierung von Formular-Antworten, Umfragen und konversationellen Datenerhebungen mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/custom/typeform/
markdown: https://tajo.io/de/docs/connectors/custom/typeform.md
lang: de-DE
robots: noindex
---

Beantrage frühzeitigen Zugang

Gib deinen Vornamen und deine geschäftliche E-Mail-Adresse ein. Wir senden dir einen Link, mit dem du deine Anfrage für den Tajo-Zugang bestätigst.

# Typeform Connector

Connector-Status: Geplant Noch nicht gebaut. Tajo betreibt diesen Connector heute nicht.

| Quellfeld | Zielfeld | Beispielwert |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Verbinde Typeform über Tajo mit Brevo, um Formular-Antworten automatisch zu synchronisieren, Leads aus konversationellen Formularen zu erfassen und Marketing-Automationen basierend auf Umfragen und Quiz-Ergebnissen auszulösen.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Typeform |
| **Kategorie** | Forms & Surveys (Custom) |
| **Einrichtungsaufwand** | Einfach |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Antworten, Kontakte, Events, Formulare |
| **Authentifizierung** | OAuth 2.0 / Personal Access Token |

## Funktionen

- **Echtzeit-Antwort-Synchronisation** - Erfasse Formular-Einreichungen automatisch via Webhooks
- **Kontakterstellung** - Erstelle oder aktualisiere Brevo-Kontakte aus Formular-Antworten
- **Lead Scoring** - Nutze Quiz-Ergebnisse und Formulardaten zur Lead-Qualifizierung
- **Hidden Fields** - Übergib Kund:innen-Daten über Hidden Fields für personalisierte Formulare
- **Bedingtes Mapping** - Mappe verschiedene Formularfelder basierend auf Antwortlogik
- **Multi-Form-Support** - Verbinde mehrere Typeforms mit verschiedenen Brevo-Listen

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Ein Typeform-Konto (Basic-Plan oder höher für Webhooks)
2. Einen Personal Access Token aus den [Typeform-Konto-Einstellungen](https://admin.typeform.com/account#/section/tokens)
3. Ein Brevo-Konto mit API-Zugriff
4. Ein Tajo-Konto mit Connector-Berechtigungen

## Authentifizierung

### Personal Access Token

```bash
# Generate a token at https://admin.typeform.com/account#/section/tokens
export TYPEFORM_ACCESS_TOKEN=tfp_your_personal_access_token
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

### OAuth 2.0

```javascript
// OAuth 2.0 Authorization Flow
const authUrl = 'https://api.typeform.com/oauth/authorize?' +
  new URLSearchParams({
    client_id: process.env.TYPEFORM_CLIENT_ID,
    redirect_uri: 'https://your-app.com/callback',
    scope: 'forms:read responses:read webhooks:write accounts:read',
    state: generateState()
  });

// Exchange authorization code for access token
const tokenResponse = await fetch('https://api.typeform.com/oauth/token', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: new URLSearchParams({
    grant_type: 'authorization_code',
    code: authorizationCode,
    client_id: process.env.TYPEFORM_CLIENT_ID,
    client_secret: process.env.TYPEFORM_CLIENT_SECRET,
    redirect_uri: 'https://your-app.com/callback'
  })
});
```

## Konfiguration

### Grundeinrichtung

```yaml
connectors:
  typeform:
    enabled: true
    access_token: "${TYPEFORM_ACCESS_TOKEN}"

    forms:
      - form_id: "abc123"
        list_id: 5
        mapping:
          email_field: "email"
          name_field: "full_name"
      - form_id: "xyz789"
        list_id: 6
        mapping:
          email_field: "work_email"

    sync:
      responses: true
      contacts: true
      events: true

    webhook:
      enabled: true
      secret: "${TYPEFORM_WEBHOOK_SECRET}"
```

### Feld-Mapping

```yaml
field_mapping:
  # Map Typeform field references to Brevo attributes
  email: email
  name: FIRSTNAME
  company: COMPANY
  phone: SMS
  score: LEAD_SCORE
  quiz_result: QUIZ_SCORE
  nps_rating: NPS_SCORE
  feedback: LAST_FEEDBACK
```

## API-Endpoints

| Endpoint | Methode | Beschreibung |
| --- | --- | --- |
| `https://api.typeform.com/forms` | GET | Alle Formulare auflisten |
| `https://api.typeform.com/forms/{form_id}` | GET | Formular abrufen |
| `https://api.typeform.com/forms` | POST | Formular erstellen |
| `https://api.typeform.com/forms/{form_id}` | PUT | Formular aktualisieren |
| `https://api.typeform.com/forms/{form_id}/responses` | GET | Antworten abrufen |
| `https://api.typeform.com/forms/{form_id}/responses` | DELETE | Antworten löschen |
| `https://api.typeform.com/forms/{form_id}/webhooks/{tag}` | PUT | Webhook erstellen/aktualisieren |
| `https://api.typeform.com/forms/{form_id}/webhooks/{tag}` | GET | Webhook abrufen |
| `https://api.typeform.com/forms/{form_id}/webhooks` | GET | Webhooks auflisten |

## Code-Beispiele

### Connector initialisieren

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('typeform', {
  accessToken: process.env.TYPEFORM_ACCESS_TOKEN,
  forms: ['abc123', 'xyz789']
});
```

### Formular-Antworten abrufen

```javascript
// Fetch responses using the Responses API
const response = await fetch(
  'https://api.typeform.com/forms/abc123/responses?' +
    new URLSearchParams({
      page_size: 25,
      since: '2024-01-01T00:00:00Z',
      completed: 'true'
    }),
  {
    headers: {
      'Authorization': `Bearer ${process.env.TYPEFORM_ACCESS_TOKEN}`
    }
  }
);

const data = await response.json();

// Sync each response to Brevo
for (const item of data.items) {
  const answers = item.answers;
  const email = answers.find(a => a.field.ref === 'email')?.email;

  if (email) {
    await tajo.contacts.sync({
      email,
      attributes: {
        FIRSTNAME: answers.find(a => a.field.ref === 'name')?.text,
        LEAD_SCORE: item.calculated?.score || 0
      },
      listIds: [5]
    });
  }
}
```

### Webhooks einrichten

```javascript
// Register a webhook for real-time response notifications
await fetch(
  'https://api.typeform.com/forms/abc123/webhooks/tajo-sync',
  {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer ${process.env.TYPEFORM_ACCESS_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      url: 'https://api.example.com/webhooks/typeform',
      enabled: true,
      secret: process.env.TYPEFORM_WEBHOOK_SECRET
    })
  }
);
```

Caution

Die Adresse `example.com` oben ist ein Platzhalter, bis der Tajo-Endpunkt verfügbar ist.

### Webhook-Events verarbeiten

```javascript
app.post('/webhooks/typeform', async (req, res) => {
  // Verify webhook signature
  const signature = req.headers['typeform-signature'];
  const isValid = verifyTypeformSignature(
    req.rawBody, signature, process.env.TYPEFORM_WEBHOOK_SECRET
  );

  if (!isValid) return res.status(401).send('Unauthorized');

  const { form_response } = req.body;

  await tajo.connectors.handleWebhook('typeform', {
    topic: 'form_response',
    payload: form_response
  });

  res.status(200).send('OK');
});
```

## Rate Limits

| Endpoint | Rate Limit | Hinweise |
| --- | --- | --- |
| Create-API | 2 Anfragen/Sek. | Formularerstellung und -aktualisierungen |
| Responses-API | 2 Anfragen/Sek. | Antwort-Abruf |
| Webhooks-API | 2 Anfragen/Sek. | Webhook-Management |
| Alle Endpoints | 120 Anfragen/Min. | Globales Rate Limit |

Antwort-Pagination

Die Responses-API liefert maximal 1.000 Antworten pro Anfrage. Nutze die Cursor-Parameter `before` oder `after` für die Pagination, wenn du große Antwortmengen abrufst.

## Fehlerbehebung

| Problem | Ursache | Lösung |
| --- | --- | --- |
| Webhook nicht empfangen | Webhook deaktiviert | Webhook im Typeform-Dashboard aktivieren |
| Fehlende Antworten | Filter angewendet | `since`/`until` und `completed`-Parameter prüfen |
| Auth-Fehler 401 | Token abgelaufen | Neuen Personal Access Token generieren |
| Rate Limit 429 | Zu viele Anfragen | Anfrage-Throttling implementieren |
| Leere Antworten | Optionale Felder | Null-/undefined-Antwortwerte behandeln |

### Debug-Modus

```yaml
connectors:
  typeform:
    debug: true
    log_level: verbose
    log_webhooks: true
    log_responses: true
```

## Best Practices

1. **Webhooks nutzen** - Bevorzuge Webhooks gegenüber Polling für Echtzeit-Antwort-Erfassung
2. **Signaturen validieren** - Verifiziere Webhook-Signaturen zur Sicherheit
3. **Hidden Fields nutzen** - Befülle bekannte Kund:innen-Daten in Formularen vor
4. **Feldreferenzen mappen** - Nutze stabile Feld-`ref`-Werte statt Feld-IDs
5. **Teilantworten behandeln** - Berücksichtige optionale und übersprungene Fragen
6. **Retry-Logik einrichten** - Implementiere idempotente Webhook-Verarbeitung

## Sicherheit

- **OAuth 2.0** - Gescopte Token-basierte Authentifizierung
- **Webhook-Signaturen** - SHA-256-HMAC-Signatur-Validierung
- **Nur HTTPS** - Alle API-Endpoints erfordern TLS
- **Token-Scoping** - Fordere minimal erforderliche OAuth-Scopes an
- **Secret-Management** - Speichere Tokens in Umgebungsvariablen oder Secret-Managern
- **DSGVO-Konformität** - Nutze die Delete-Responses-API für Datenlöschungsanfragen

## Verwandte Ressourcen

- [Calendly Connector](https://tajo.io/de/docs/connectors/custom/calendly)
- [Zapier Connector](https://tajo.io/de/docs/connectors/custom/zapier)
- [Customer-Sync-Skill](https://tajo.io/de/docs/skills/data-sync/customer-sync)
- [Typeform Developer-Dokumentation](https://www.typeform.com/developers/)