---
title: "Mailgun Connector"
description: "Vollständiger Leitfaden zur Mailgun-Integration für die Synchronisation von E-Mail-Zustelldaten, Engagement-Metriken und Transactional-E-Mail-Events mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/marketing/mailgun/
markdown: https://tajo.io/de/docs/connectors/marketing/mailgun.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.

# Mailgun 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 Mailgun über Tajo mit Brevo, um deine Transactional- und Marketing-E-Mail-Daten zu vereinheitlichen, Zustell-Events und Engagement-Metriken zu synchronisieren und deine E-Mail-Infrastruktur in einer einzigen Kundensicht zu konsolidieren.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | Mailgun (by Sinch) |
| **Kategorie** | E-Mail-Marketing |
| **Einrichtungsaufwand** | Einfach |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Events, Kontakte, Zustellbarkeit, Kampagnen |
| **Auth-Methode** | API-Schlüssel (HTTP Basic Auth) |

## Funktionen

- **Zustell-Event-Sync** - Tracke Delivered-, Bounced-, Opened- und Clicked-Events
- **Engagement-Metriken** - Synchronisiere Open- und Click-Rates in Brevo-Kontaktattribute
- **Bounce-Management** - Unterdrücke gebouncte Adressen automatisch in Brevo
- **Umgang mit Spam-Beschwerden** - Synchronisiere Spam-Complaints für die Listen-Hygiene
- **Domain-Reputation** - Überwache die Gesundheit der Sender-Domain und die E-Mail-Zustellbarkeit
- **Tracking von Transactional-E-Mails** - Verbinde Transactional-Sends mit Marketingdaten

## Voraussetzungen

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

1. Ein Mailgun-Konto mit einer verifizierten Sender-Domain
2. Einen Mailgun-API-Schlüssel aus dem [Mailgun-Dashboard](https://app.mailgun.com/settings/api_security)
3. Ein Brevo-Konto mit API-Zugriff
4. Ein Tajo-Konto mit Connector-Berechtigungen

## Authentifizierung

### API-Schlüssel-Authentifizierung

Mailgun nutzt HTTP Basic Authentication mit `api` als Benutzername und deinem API-Schlüssel als Passwort:

```bash
# Get your API key from https://app.mailgun.com/settings/api_security
export MAILGUN_API_KEY=key-your-api-key
export MAILGUN_DOMAIN=your-domain.com
export TAJO_API_KEY=your_tajo_api_key
export BREVO_API_KEY=your_brevo_api_key
```

```javascript
// HTTP Basic Auth format
const headers = {
  'Authorization': `Basic ${Buffer.from(
    `api:${process.env.MAILGUN_API_KEY}`
  ).toString('base64')}`
};

// Or using curl
// curl -s --user 'api:YOUR_API_KEY' ...
```

API-Schlüssel-Typen

Mailgun bietet domain-spezifische Sending Keys und kontoweite API-Schlüssel an. Nutze Domain-Sending-Keys für Messaging-Operationen und den Account-API-Schlüssel für administrative Aufgaben.

## Konfiguration

### Grundeinrichtung

```yaml
connectors:
  mailgun:
    enabled: true
    api_key: "${MAILGUN_API_KEY}"
    domain: "${MAILGUN_DOMAIN}"
    region: "us"  # or "eu" for EU region

    sync:
      events: true
      contacts: true
      bounces: true
      complaints: true
      schedule: "*/15 * * * *"  # Every 15 minutes

    webhook:
      signing_key: "${MAILGUN_WEBHOOK_SIGNING_KEY}"

    lists:
      engaged: 30
      bounced: 31
      complained: 32
```

### Feldzuordnung

```yaml
field_mapping:
  email: email
  first_name: FIRSTNAME
  last_name: LASTNAME
  open_rate: MG_OPEN_RATE
  click_rate: MG_CLICK_RATE
  last_delivered: MG_LAST_DELIVERED
  bounce_type: MG_BOUNCE_TYPE
  engagement_score: MG_ENGAGEMENT
  unsubscribed: MG_UNSUBSCRIBED
```

## API-Endpoints

| Endpoint | Methode | Beschreibung |
| --- | --- | --- |
| `https://api.mailgun.net/v3/{domain}/messages` | POST | E-Mail-Nachrichten versenden |
| `https://api.mailgun.net/v3/{domain}/events` | GET | Event-Logs abfragen |
| `https://api.mailgun.net/v3/{domain}/bounces` | GET | Bounces auflisten |
| `https://api.mailgun.net/v3/{domain}/complaints` | GET | Complaints auflisten |
| `https://api.mailgun.net/v3/{domain}/unsubscribes` | GET | Abmeldungen auflisten |
| `https://api.mailgun.net/v3/{domain}/tags` | GET | Tags auflisten |
| `https://api.mailgun.net/v3/{domain}/tags/{tag}/stats` | GET | Statistiken für ein Tag abrufen |
| `https://api.mailgun.net/v3/lists` | GET | Mailing-Listen auflisten |
| `https://api.mailgun.net/v3/domains` | GET | Domains auflisten |
| `https://api.mailgun.net/v4/address/validate` | POST | E-Mail-Adresse validieren |

EU-Region

Nutze für Mailgun-Konten in der EU `https://api.eu.mailgun.net` statt `https://api.mailgun.net` für alle API-Endpoints.

## 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('mailgun', {
  apiKey: process.env.MAILGUN_API_KEY,
  domain: process.env.MAILGUN_DOMAIN,
  region: 'us'
});
```

### Eine Nachricht über die Mailgun-API senden

```javascript
// Send an email using Mailgun's Messages API
const formData = new URLSearchParams();
formData.append('from', `Your App <noreply@${domain}>`);
formData.append('to', 'recipient@example.com');
formData.append('subject', 'Welcome to our platform');
formData.append('html', '<h1>Welcome!</h1><p>Thanks for signing up.</p>');
formData.append('o:tag', 'welcome-email');
formData.append('o:tracking', 'yes');

const response = await fetch(
  `https://api.mailgun.net/v3/${domain}/messages`,
  {
    method: 'POST',
    headers: {
      'Authorization': `Basic ${Buffer.from(`api:${apiKey}`).toString('base64')}`
    },
    body: formData
  }
);

const result = await response.json();
// { id: '<message-id@domain.com>', message: 'Queued. Thank you.' }
```

### E-Mail-Events mit Brevo synchronisieren

```javascript
// Query Mailgun events and sync engagement data
const eventsResponse = await fetch(
  `https://api.mailgun.net/v3/${domain}/events?` +
    new URLSearchParams({
      begin: lastSyncDate,
      ascending: 'yes',
      limit: 300,
      event: 'delivered OR opened OR clicked'
    }),
  {
    headers: {
      'Authorization': `Basic ${Buffer.from(`api:${apiKey}`).toString('base64')}`
    }
  }
);

const { items, paging } = await eventsResponse.json();

for (const event of items) {
  const email = event.recipient;

  switch (event.event) {
    case 'delivered':
      await tajo.contacts.update(email, {
        attributes: { MG_LAST_DELIVERED: event.timestamp }
      });
      break;
    case 'opened':
      await tajo.events.track({
        email,
        event: 'email_opened',
        properties: { subject: event.message.headers.subject }
      });
      break;
    case 'clicked':
      await tajo.events.track({
        email,
        event: 'email_clicked',
        properties: { url: event.url }
      });
      break;
  }
}

// Follow pagination for more events
if (paging.next) {
  // Fetch next page using paging.next URL
}
```

### Mailgun-Webhooks verarbeiten

```javascript
const crypto = require('crypto');

app.post('/webhooks/mailgun', async (req, res) => {
  // Verify webhook signature
  const { timestamp, token, signature } = req.body.signature;
  const encodedToken = crypto
    .createHmac('sha256', process.env.MAILGUN_WEBHOOK_SIGNING_KEY)
    .update(timestamp.concat(token))
    .digest('hex');

  if (encodedToken !== signature) {
    return res.status(401).send('Unauthorized');
  }

  const eventData = req.body['event-data'];
  const event = eventData.event;
  const email = eventData.recipient;

  await tajo.connectors.handleWebhook('mailgun', {
    topic: event,
    payload: eventData
  });

  // Handle bounce suppression
  if (event === 'failed' && eventData.severity === 'permanent') {
    await tajo.contacts.update(email, {
      attributes: { MG_BOUNCE_TYPE: 'hard_bounce' },
      emailBlacklisted: true
    });
  }

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

### Bounces und Complaints synchronisieren

```javascript
// Sync bounced addresses for list hygiene
const bouncesResponse = await fetch(
  `https://api.mailgun.net/v3/${domain}/bounces?limit=100`,
  {
    headers: {
      'Authorization': `Basic ${Buffer.from(`api:${apiKey}`).toString('base64')}`
    }
  }
);

const { items: bounces } = await bouncesResponse.json();

for (const bounce of bounces) {
  await tajo.contacts.update(bounce.address, {
    attributes: {
      MG_BOUNCE_TYPE: bounce.error.includes('550') ? 'hard_bounce' : 'soft_bounce',
      MG_BOUNCE_DATE: bounce.created_at
    },
    emailBlacklisted: bounce.error.includes('550')
  });
}
```

## Rate Limits

| Endpoint | Limit | Hinweise |
| --- | --- | --- |
| Messages API | Variiert je nach Plan | 100/Std. (Free), unbegrenzt (Paid) |
| Events API | Kein explizites Limit | Pagination mit max. 300 Items nutzen |
| Validation API | Abhängig vom Plan | Pay-per-Validation |
| Webhooks | Echtzeit | Kein Rate Limit bei der Zustellung |
| Suppressions API | Kein explizites Limit | Standard-Rate-Limiting gilt |

Versand-Limits

Mailgun wendet Versand-Limits abhängig von deinem Plan und der Domain-Reputation an. Neue Domains starten mit niedrigeren Limits, die mit steigender Absender-Reputation zunehmen. Behalte die Domain-Statistiken im Mailgun-Dashboard im Blick.

## Fehlerbehebung

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Ungültiger API-Schlüssel | API-Schlüssel im Mailgun-Dashboard prüfen |
| Domain nicht verifiziert | DNS-Einträge fehlen | Erforderliche TXT-, CNAME-, MX-Einträge ergänzen |
| Webhook nicht empfangen | URL nicht erreichbar | Sicherstellen, dass die Webhook-URL öffentlich erreichbar ist |
| Events fehlen | Zeitraum zu eng | Die Parameter `begin`/`end` erweitern |
| Niedrige Zustellbarkeit | Domain-Reputation | Domain-Statistiken und Authentifizierung überprüfen |

### Debug-Modus

```yaml
connectors:
  mailgun:
    debug: true
    log_level: verbose
    log_webhooks: true
    log_events: true
```

## Best Practices

1. **Sender-Domains verifizieren** - Schließe die DNS-Verifizierung für eine optimale E-Mail-Zustellbarkeit ab
2. **Webhooks für Events nutzen** - Echtzeit-Webhook-Zustellung statt Polling der Events-API
3. **Proaktiv mit Bounces umgehen** - Hard Bounces sofort in Brevo unterdrücken
4. **Nachrichten taggen** - Nutze Tags, um die E-Mail-Performance zu kategorisieren und zu analysieren
5. **Domain-Reputation überwachen** - Verfolge die Zustellbarkeitsmetriken im Mailgun-Dashboard
6. **E-Mail-Validierung nutzen** - Validiere Adressen, bevor du sie zu Brevo-Listen hinzufügst

## Sicherheit

- **HTTP Basic Auth** - Der API-Schlüssel wird über den Authorization-Header übertragen
- **Webhook-Signaturen** - HMAC-SHA256-Signaturprüfung
- **Domain-Verifizierung** - SPF-, DKIM- und DMARC-DNS-Authentifizierung
- **IP-Whitelisting** - Verfügbar bei Plänen mit dedizierter IP
- **TLS-Verschlüsselung** - Alle API-Endpoints erfordern HTTPS
- **Schlüsselrotation** - Rotiere API-Schlüssel regelmäßig über das Mailgun-Dashboard

## Verwandte Ressourcen

- [Brevo Connector](https://tajo.io/de/docs/connectors/marketing/brevo)
- [Segment Connector](https://tajo.io/de/docs/connectors/custom/segment)
- [Customer-Sync-Skill](https://tajo.io/de/docs/skills/data-sync/customer-sync)
- [Mailgun API-Dokumentation](https://documentation.mailgun.com/)