# Segmente API

> Filter über Ihre Kontakte speichern, die passenden Kontakte auflisten und Segmente mit Tracking über die Zeit verfolgen.

Basis-URL: `https://api.emailit.com/v2`. Authentifizieren Sie sich mit `Authorization: Bearer <API key>`.

## Segment erstellen — POST /segments

> Erstellen Sie ein Segment, einen gespeicherten Filter über Ihre Kontakte aus allen Kontakten oder ausgewählten Kontaktlisten, und legen Sie fest, ob es Tracking nutzt. Alpha: nur für das Emailit-Team zugänglich.

# Segment erstellen

Erstellt ein Segment: einen gespeicherten Filter über die Kontakte des Workspaces. Erfordert einen API-Schlüssel mit dem Scope `full`.

Ein Segment enthält die Kontakte aus seiner Quelle (den Abonnenten der Kontaktlisten in `audience_ids` oder allen Kontakten, wenn das Feld leer ist), die seinen `conditions` entsprechen. Die Mitgliedschaft wird jedes Mal live ausgewertet, wenn das Segment gezählt, aufgelistet, in der Vorschau geprüft oder von einer Kampagne beim Senden verwendet wird. Siehe [Segmente](/de/docs/segments/).

Jeder Tarif enthält eine bestimmte Anzahl von Segmenten pro Workspace, mit oder ohne Tracking. Siehe [Limits](/de/docs/limits/#plan-limits).

`POST /segments`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Body-Parameter

- `name` (string, erforderlich): Name des Segments, bis zu 191 Zeichen.

- `description` (string | null): Notiz für Ihr Team, bis zu 1.000 Zeichen.

- `audience_ids` (string[]): Die Quelle: IDs von Kontaktlisten (`aud_…`) in diesem Workspace, bis zu 100. Das Segment enthält nur Kontakte, die bei mindestens einer davon angemeldet sind. Leer oder weggelassen bedeutet alle Kontakte im Workspace.

- `conditions` (object): Die Regeln, denen Kontakte entsprechen müssen, beschrieben unter [Bedingungen](#conditions). Lassen Sie das Feld weg, um alle Kontakte aus der Quelle aufzunehmen.

- `tracked` (boolean): Speichert die Mitglieder des Segments, sodass Beitritte und Austritte von Kontakten zu Events für [Automatisierungen](/de/docs/automations/triggers/#segment-triggers) und [Webhooks](/de/docs/webhooks/event-types/#segment-events) werden. Enthalten in Pro, Business und Custom. Sie legen es hier fest und können es später nicht mehr ändern. Siehe [Segmente mit Tracking](/de/docs/segments/tracked/).

## Bedingungen

`conditions` enthält Gruppen von Regeln. Das `match` der obersten Ebene verknüpft die Gruppen, und das `match` jeder Gruppe verknüpft ihre Regeln:

```json
{
  "match": "all",
  "groups": [
    { "match": "any", "rules": [{ "field": "email_domain", "operator": "in", "value": ["acme.com", "globex.io"] }] },
    { "match": "all", "rules": [{ "field": "status", "operator": "equals", "value": "subscribed" }] }
  ]
}
```

- `match` ist `all` (Standardwert) oder `any`, auf der obersten Ebene und in jeder Gruppe.
- Lassen Sie `conditions` weg oder senden Sie keine Gruppen, um alle Kontakte aus der Quelle aufzunehmen. Leere Gruppen werden verworfen.
- Die flache Form `{ "match": "any", "rules": [...] }` wird ebenfalls akzeptiert und als eine Gruppe gespeichert.
- Ein Segment kann bis zu 10 Gruppen und insgesamt 50 Regeln haben.

### Felder

| Feld | Typ | Hinweise |
| --- | --- | --- |
| `email` | string | |
| `email_domain` | string | Der Teil der Adresse nach `@`. |
| `first_name`, `last_name` | string | |
| `status` | enum | `subscribed` (nicht global abgemeldet und bei mindestens einer Kontaktliste angemeldet, sodass Kampagnen den Kontakt erreichen können) oder `unsubscribed`. Operatoren: `equals`, `not_equals`. |
| `created_at`, `updated_at` | datetime | Zeitpunkt, zu dem der Kontakt erstellt oder zuletzt geändert wurde, in UTC verglichen. |
| `audience` | audience | Angemeldete Mitgliedschaft. `in` trifft auf Kontakte zu, die bei einer der angegebenen Kontaktlisten angemeldet sind, `not_in` auf Kontakte, die bei keiner davon angemeldet sind. |
| `tags` | tags | Die [Tags](/de/docs/contacts/tags-and-score/) des Kontakts. Werte werden in Kleinbuchstaben verglichen. |
| `score` | score | Der [Lead-Score](/de/docs/contacts/tags-and-score/#lead-score) des Kontakts. |
| `custom_fields.<key>` | hängt vom Feld ab | Textfelder sind `string`, Zahlenfelder `number`, Datumsfelder `date` (`YYYY-MM-DD`), Boolean-Felder `boolean`, Auswahlfelder `enum` und Mehrfachauswahlfelder `multi`. |
| `orders_count`, `total_spent`, `average_order_value` | metric | Aus den [Bestellungen](/de/docs/commerce/) des Kontakts. 0 bei Kontakten ohne Bestellungen. Beträge sind in der Bestellwährung des Kontakts. |
| `first_order_at`, `last_order_at` | moment | Bei Kontakten ohne Bestellungen nicht gesetzt. |
| `expected_next_order_at` | moment | Die letzte Bestellung plus der durchschnittliche Abstand zwischen den Bestellungen des Kontakts. Ab der zweiten Bestellung gesetzt; kann in der Zukunft liegen. |
| `churn_risk` | enum | `low`, `medium` oder `high`: die Zeit seit der letzten Bestellung im Vergleich zum üblichen Abstand des Kontakts (mindestens 14 Tage) oder bei Einmalkäufern zu 90 Tagen. Ohne Bestellungen nicht gesetzt. |
| `last_active_at` | moment | Wann das [Tracking-Skript](/de/docs/commerce/connect-your-shop/#the-tracking-script) den Kontakt zuletzt auf Ihrer Website gesehen hat. |
| `purchased` | purchase | Bestellungen, siehe [Aktivitätsregeln](#activity-rules). |
| `viewed_product` | view | Vom Tracking-Skript erfasste Produktaufrufe. |
| `cart` | cart | Offene und abgebrochene Warenkörbe. |
| `used_coupon` | coupon | Bestellungen, in denen ein Gutscheincode verwendet wurde. |
| `campaign_activity` | campaign_activity | Empfangene, geöffnete oder geklickte Kampagnen-E-Mails. |

[Segmentfelder auflisten](/de/docs/api-reference/segments/fields/) gibt die Felder Ihres Workspaces zurück, einschließlich seiner eigenen Felder und Kontaktlisten, mit den Operatoren, die jedes Feld akzeptiert.

### Operatoren

| Typ | Operatoren |
| --- | --- |
| string | `equals`, `not_equals`, `contains`, `not_contains`, `starts_with`, `ends_with`, `in`, `not_in`, `is_set`, `is_not_set` |
| number | `equals`, `not_equals`, `greater_than`, `greater_than_or_equal`, `less_than`, `less_than_or_equal`, `between`, `is_set`, `is_not_set` |
| date | `on`, `before`, `after`, `between`, `in_last_days`, `more_than_days_ago`, `in_next_days`, `is_set`, `is_not_set` |
| datetime | `on`, `before`, `after`, `between`, `in_last_days`, `more_than_days_ago` |
| boolean | `is_true`, `is_false`, `is_set`, `is_not_set` |
| enum | `in`, `not_in`, `is_set`, `is_not_set` |
| multi | `in` (enthält mindestens einen), `contains_all` (enthält alle), `not_in` (enthält keinen), `is_set`, `is_not_set` |
| audience | `in`, `not_in` |
| tags | `in` (enthält mindestens eines), `contains_all` (enthält alle), `not_in` (enthält keines), `is_set` (hat mindestens ein Tag), `is_not_set` (hat keine Tags) |
| score | `equals`, `not_equals`, `greater_than`, `greater_than_or_equal`, `less_than`, `less_than_or_equal`, `between` |
| metric | `equals`, `not_equals`, `greater_than`, `greater_than_or_equal`, `less_than`, `less_than_or_equal`, `between` |
| moment | `on`, `before`, `after`, `between`, `in_last_days`, `more_than_days_ago`, `in_next_days`, `is_set`, `is_not_set` |
| purchase, view, coupon | `has`, `has_not` |
| cart | `has_open_cart`, `has_abandoned_cart`, `has_no_open_cart` |
| campaign_activity | `received`, `not_received`, `opened`, `not_opened`, `clicked`, `not_clicked`, `received_not_opened`, `received_not_clicked` |

### Werte

- Textvergleiche bei String-Feldern ignorieren die Groß-/Kleinschreibung. Werte von Auswahl- und Mehrfachauswahlfeldern müssen exakt übereinstimmen.
- `not_equals`, `not_contains` und `not_in` treffen auch auf Kontakte zu, die keinen Wert haben.
- `in`, `not_in` und `contains_all` nehmen eine Liste mit bis zu 100 Werten an. Textwerte können bis zu 500 Zeichen lang sein.
- `between` nimmt `[from, to]` an, beide einschließlich: zwei Zahlen oder zwei Datumsangaben im Format `YYYY-MM-DD`.
- `on`, `before` und `after` nehmen ein Datum im Format `YYYY-MM-DD` an. `before` und `after` schließen diesen Tag nicht ein.
- `in_last_days`, `more_than_days_ago` und `in_next_days` nehmen eine ganze Zahl von Tagen von 1 bis 3650 an, gezählt ab dem Moment, in dem das Segment ausgewertet wird. Eigene Felder vom Typ Datum vergleichen Kalendertage in UTC; `created_at` und `updated_at` verwenden exakte Zeitpunkte, daher bedeutet `in_last_days` mit `7` die letzten 7 × 24 Stunden.
- `is_set`, `is_not_set`, `is_true` und `is_false` nehmen keinen Wert an. `is_true` trifft auf `true`, `1`, `yes` und `on` zu, `is_false` auf `false`, `0`, `no` und `off`.
- Eine gespeicherte Regel, die nicht mehr anwendbar ist, etwa weil sich der Typ ihres eigenen Felds geändert hat, trifft auf keine Kontakte zu. Regeln für ein gelöschtes eigenes Feld funktionieren mit den Werten weiter, die Kontakte noch haben, aber neue Regeln müssen ein bestehendes Feld verwenden.

### Aktivitätsregeln

`purchased`, `viewed_product`, `cart`, `used_coupon` und `campaign_activity` nehmen ein Objekt als `value` an. Jeder Schlüssel ist optional.

| Feld | Schlüssel in `value` |
| --- | --- |
| `purchased` | `days`: nur Bestellungen der letzten N Tage. `product_ids`: Bestellungen mit einem dieser Produkte (die Produkt-IDs Ihres Shops). `categories`: Bestellungen mit einem Produkt in einer dieser Kategorien. `min_count`: mindestens so viele passende Bestellungen (Standardwert 1, bis zu 1000). Stornierte Bestellungen zählen nicht. |
| `viewed_product` | `days`, `product_ids`, `categories` und `min_count` wie oben, gezählt werden Produktaufrufe. |
| `cart` | `days` nur mit `has_abandoned_cart`: in den letzten N Tagen abgebrochene Warenkörbe. `has_open_cart` trifft auf einen aktiven Warenkorb zu, `has_no_open_cart` auf Kontakte ohne aktiven oder abgebrochenen Warenkorb. |
| `used_coupon` | `days` und `coupon`: der Schlüssel eines [Gutscheins](/de/docs/commerce/coupons/). Ohne `coupon` zählt jeder Code. |
| `campaign_activity` | `campaign_id`: eine Kampagne (`cmp_...`), ohne Angabe jede Kampagne. `days`: nur die letzten N Tage, ohne Angabe der gesamte Zeitraum. |

`days` ist eine ganze Zahl von 1 bis 3650. `has_not` ist das Gegenteil von `has` mit demselben Wert.

```json
{
  "match": "all",
  "groups": [
    { "match": "all", "rules": [
      { "field": "purchased", "operator": "has", "value": { "categories": ["Shoes"], "days": 180 } },
      { "field": "churn_risk", "operator": "in", "value": ["medium", "high"] },
      { "field": "campaign_activity", "operator": "clicked", "value": { "days": 90 } }
    ] }
  ]
}
```

`received_not_opened` und `received_not_clicked` treffen auf Kontakte zu, die mindestens eine passende Kampagnen-E-Mail erhalten und keine davon geöffnet bzw. geklickt haben. Öffnungen sind ungenau: Apple Mail lädt die Bilder jeder E-Mail, die es empfängt.

## Rückgabe

Gibt `201 Created` mit dem [Segment-Objekt](/de/docs/api-reference/segments/get/) zurück, einschließlich `contacts_count` und `subscribed_count`. Ein neues Segment mit Tracking beginnt mit `tracking.status` auf `syncing`, während Emailit seine aktuellen Mitglieder erfasst.

| Status | Wann |
| --- | --- |
| `400` | `name` fehlt oder ein Feld hat den falschen Typ. |
| `403` | `tracked` ist `true` und der Tarif enthält keine Segmente mit Tracking. Der Body ist `{"error": "plan_required", "required_plan": "pro", ...}`. |
| `422` | Ein Feld oder eine Regel ist ungültig: `errors` ist nach dem Pfad geschlüsselt, etwa `conditions.groups.0.rules.1.value`, und `message` wiederholt das erste Problem. Wird auch zurückgegeben, wenn der Workspace das Segmentlimit seines Tarifs erreicht hat; dieser Body enthält `usage.used` und `usage.limit`. |

**Anfrage** `POST /segments`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/segments \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Pro customers renewing soon",
    "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
    "conditions": {
      "match": "all",
      "groups": [{
        "match": "all",
        "rules": [
          { "field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"] },
          { "field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30 }
        ]
      }]
    },
    "tracked": true
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'Pro customers renewing soon',
    audience_ids: ['aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a'],
    conditions: {
      match: 'all',
      groups: [{
        match: 'all',
        rules: [
          { field: 'custom_fields.plan', operator: 'in', value: ['pro', 'enterprise'] },
          { field: 'custom_fields.renews_on', operator: 'in_next_days', value: 30 },
        ],
      }],
    },
    tracked: true,
  }),
});
const segment = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/segments",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "name": "Pro customers renewing soon",
        "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
        "conditions": {
            "match": "all",
            "groups": [{
                "match": "all",
                "rules": [
                    {"field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"]},
                    {"field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30},
                ],
            }],
        },
        "tracked": True,
    },
)
segment = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('segments', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'name' => 'Pro customers renewing soon',
        'audience_ids' => ['aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a'],
        'conditions' => [
            'match' => 'all',
            'groups' => [[
                'match' => 'all',
                'rules' => [
                    ['field' => 'custom_fields.plan', 'operator' => 'in', 'value' => ['pro', 'enterprise']],
                    ['field' => 'custom_fields.renews_on', 'operator' => 'in_next_days', 'value' => 30],
                ],
            ]],
        ],
        'tracked' => true,
    ],
]);
$segment = json_decode($response->getBody(), true);
```

**201**

```json
{
  "object": "segment",
  "id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
  "name": "Pro customers renewing soon",
  "description": null,
  "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
  "conditions": {
    "match": "all",
    "groups": [
      {
        "match": "all",
        "rules": [
          { "field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"] },
          { "field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30 }
        ]
      }
    ]
  },
  "tracked": true,
  "tracking": {
    "status": "syncing",
    "synced_at": null
  },
  "contacts_count": 412,
  "subscribed_count": 398,
  "created_at": "2026-10-18T12:00:00.000000+00:00",
  "updated_at": "2026-10-18T12:00:00.000000+00:00"
}
```

**403**

```json
{
  "error": "plan_required",
  "message": "Tracked segments are included with Pro and Business.",
  "required_plan": "pro"
}
```

**422 Validierung**

```json
{
  "message": "Validation failed. conditions.groups.0.rules.1.value: Enter a whole number of days between 1 and 3650.",
  "errors": {
    "conditions.groups.0.rules.1.value": [
      "Enter a whole number of days between 1 and 3650."
    ]
  }
}
```

**422 Limit**

```json
{
  "error": "Pay as you go includes 3 segments.",
  "message": "Pay as you go includes 3 segments.",
  "usage": {
    "used": 3,
    "limit": 3
  }
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/create/

## Segment abrufen — GET /segments/{id}

> Rufen Sie ein Segment mit seiner Quelle, seinen Regeln, dem Tracking-Status und live gezählten Kontakten ab. Alpha: nur für das Emailit-Team zugänglich.

# Segment abrufen

Ruft ein Segment ab und zählt seine Kontakte zum Zeitpunkt des Aufrufs. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /segments/{id}`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Pfadparameter

- `id` (string, erforderlich): Die ID des Segments (`seg_…`).

## Rückgabe

Gibt das Segment-Objekt zurück.

- `object` (string): Immer `segment`.

- `id` (string): ID des Segments mit dem Präfix `seg_`.

- `name` (string): Name des Segments.

- `description` (string | null): Notiz für Ihr Team.

- `audience_ids` (string[]): Die Kontaktlisten der Quelle. Leer bedeutet alle Kontakte im Workspace.

- `conditions` (object): Die Regeln, als `{ "match", "groups": [{ "match", "rules": [...] }] }`. Siehe [Segment erstellen](/de/docs/api-reference/segments/create/#conditions).

- `tracked` (boolean): Ob das Segment seine Mitglieder speichert und Beitritte und Austritte meldet. Siehe [Segmente mit Tracking](/de/docs/segments/tracked/).

- `tracking` (object | null): `null` bei Segmenten ohne Tracking. Bei Segmenten mit Tracking: - `status`: `active`, wenn die Mitglieder aktuell gehalten werden, `syncing`, während Emailit die aktuellen Mitglieder erfasst, nachdem das Segment erstellt oder das Tracking fortgesetzt wurde, oder `paused`, wenn der Tarif des Workspaces keine Segmente mit Tracking mehr enthält. - `synced_at`: Zeitpunkt, zu dem das ganze Segment zuletzt mit seinen Regeln abgeglichen wurde, oder `null` vor dem ersten Abgleich.

- `contacts_count` (integer): Kontakte, die dem Segment in diesem Moment entsprechen.

- `subscribed_count` (integer): Der Teil von `contacts_count`, an den Kampagnen senden können: Kontakte, die nicht global abgemeldet und bei mindestens einer Kontaktliste angemeldet sind. Gesperrte Adressen werden trotzdem mitgezählt.

- `created_at, updated_at` (string): Zeitstempel in UTC.

Gibt `404` zurück, wenn das Segment nicht existiert.

**Anfrage** `GET /segments/{id}`

**cURL**

```bash
curl https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const segment = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
segment = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$segment = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "segment",
  "id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
  "name": "Pro customers renewing soon",
  "description": "Pro and Enterprise plans that renew in the next 30 days.",
  "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
  "conditions": {
    "match": "all",
    "groups": [
      {
        "match": "all",
        "rules": [
          { "field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"] },
          { "field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30 }
        ]
      }
    ]
  },
  "tracked": true,
  "tracking": {
    "status": "active",
    "synced_at": "2026-10-18T00:30:04.211000+00:00"
  },
  "contacts_count": 412,
  "subscribed_count": 398,
  "created_at": "2026-10-02T09:14:03.551000+00:00",
  "updated_at": "2026-10-02T09:14:03.551000+00:00"
}
```

**404**

```json
{
  "error": "Segment not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/get/

## Segment aktualisieren — POST /segments/{id}

> Ändern Sie Name, Beschreibung, Quell-Kontaktlisten oder Regeln eines Segments. Ob ein Segment Tracking nutzt, lässt sich nicht ändern. Alpha: nur für das Emailit-Team zugänglich.

# Segment aktualisieren

Aktualisiert die übergebenen Felder und lässt die übrigen unverändert. `audience_ids` und `conditions` werden als Ganzes ersetzt. Erfordert einen API-Schlüssel mit dem Scope `full`.

Kampagnen werten ein Segment beim Senden aus, daher gelten neue Regeln für jede Kampagne, die noch nicht gesendet wurde, auch für geplante.

Bei einem [Segment mit Tracking](/de/docs/segments/tracked/) gleicht eine Änderung von `audience_ids` oder `conditions` die gespeicherten Mitglieder mit den neuen Regeln ab. Für Kontakte, die durch die Änderung dem Segment beitreten oder es verlassen, werden die Events `segment.contact_added` und `segment.contact_removed` mit `reason` auf `segment_updated` gesendet. Webhooks erhalten sie, aber sie starten keine Automatisierungen.

`POST /segments/{id}`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Pfadparameter

- `id` (string, erforderlich): Die ID des Segments (`seg_…`).

## Body-Parameter

- `name` (string): Neuer Name, bis zu 191 Zeichen. Darf nicht leer sein.

- `description` (string | null): Notiz für Ihr Team, bis zu 1.000 Zeichen. `null` oder ein leerer String löscht sie.

- `audience_ids` (string[]): IDs der Kontaktlisten der Quelle. `[]` bedeutet alle Kontakte im Workspace.

- `conditions` (object): Die Regeln. Siehe [Segment erstellen](/de/docs/api-reference/segments/create/#conditions).

- `tracked` (boolean): Wird nur mit dem aktuellen Wert des Segments akzeptiert. Das Tracking wird beim Erstellen eines Segments festgelegt; um es zu ändern, erstellen Sie ein neues Segment.

## Rückgabe

Gibt das aktualisierte [Segment-Objekt](/de/docs/api-reference/segments/get/) mit neu gezählten Kontakten zurück.

| Status | Wann |
| --- | --- |
| `404` | Das Segment existiert nicht. |
| `422` | Ein Feld oder eine Regel ist ungültig, oder `tracked` weicht vom aktuellen Wert des Segments ab. `errors` ist nach Feldpfad geschlüsselt. |

**Anfrage** `POST /segments/{id}`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "name": "Pro customers renewing this month" }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ name: 'Pro customers renewing this month' }),
});
const segment = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={"name": "Pro customers renewing this month"},
)
segment = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => ['name' => 'Pro customers renewing this month'],
]);
$segment = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "segment",
  "id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
  "name": "Pro customers renewing this month",
  "description": "Pro and Enterprise plans that renew in the next 30 days.",
  "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
  "conditions": {
    "match": "all",
    "groups": [
      {
        "match": "all",
        "rules": [
          { "field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"] },
          { "field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30 }
        ]
      }
    ]
  },
  "tracked": true,
  "tracking": {
    "status": "active",
    "synced_at": "2026-10-18T00:30:04.211000+00:00"
  },
  "contacts_count": 412,
  "subscribed_count": 398,
  "created_at": "2026-10-02T09:14:03.551000+00:00",
  "updated_at": "2026-10-18T12:00:00.000000+00:00"
}
```

**404**

```json
{
  "error": "Segment not found"
}
```

**422**

```json
{
  "message": "Validation failed. tracked: Tracking is chosen when a segment is created and can't be changed. Create a new segment instead.",
  "errors": {
    "tracked": [
      "Tracking is chosen when a segment is created and can't be changed. Create a new segment instead."
    ]
  }
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/update/

## Segmente auflisten — GET /segments

> Listen Sie die Segmente eines Workspaces auf, die neuesten zuerst, optional mit Live-Zählungen und mit der Segmentnutzung des Tarifs. Alpha: nur für das Emailit-Team zugänglich.

# Segmente auflisten

Gibt die Segmente des Workspaces zurück, die neuesten zuerst, und dazu, wie viele der im Tarif enthaltenen Segmente belegt sind. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /segments`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Query-Parameter

- `page` (integer): Seitennummer, beginnend bei 1.

- `limit` (integer): Segmente pro Seite, von 1 bis 100.

- `search` (string): Abgleich mit einem Teil des Segmentnamens, ohne Beachtung der Groß-/Kleinschreibung.

- `with_counts` (boolean): Fügt jedem Segment `contacts_count` und `subscribed_count` hinzu. Das Zählen wertet jedes Segment auf der Seite aus und ist daher standardmäßig deaktiviert.

- `match`, `order`, `direction`: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

### Filterschlüssel

Filter verwenden Query-Parameter der Form `key.condition=value`, zum Beispiel `name.contains=customers` oder `created_at.after=2026-09-01`. Die Bedingungen je Typ finden Sie unter [Filtern](/de/docs/api-reference/filtering/).

| Schlüssel | Typ | Hinweise |
| --- | --- | --- |
| `name` | string | |
| `created_at` | date | |
| `updated_at` | date | |

Sortierschlüssel für `order`: `name`, `created_at`, `updated_at`.

## Rückgabe

- `data` (object[]): [Segment-Objekte](/de/docs/api-reference/segments/get/) auf dieser Seite. `contacts_count` und `subscribed_count` sind nur mit `with_counts` enthalten.

- `total_records` (integer): Anzahl der Segmente, die der Abfrage entsprechen.

- `usage` (object): Die Segmente des Workspaces im Verhältnis zu seinem Tarif: `used` (alle Segmente, mit oder ohne Tracking), `limit` (im Tarif enthaltene Segmente) und `tracking_allowed` (ob der Tarif Segmente mit Tracking enthält). Siehe [Limits](/de/docs/limits/#plan-limits).

- `next_page_url` (string | null): Pfad der nächsten Seite oder `null` auf der letzten Seite. Er enthält nur `page` und `limit`; fügen Sie Ihre Suche und Filter erneut hinzu, wenn Sie ihm folgen.

- `previous_page_url` (string | null): Pfad der vorherigen Seite oder `null` auf der ersten Seite.

**Anfrage** `GET /segments`

**cURL**

```bash
curl -G https://api.emailit.com/v2/segments \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d with_counts=true
```

**Node.js**

```javascript
const params = new URLSearchParams({ with_counts: 'true' });
const res = await fetch(`https://api.emailit.com/v2/segments?${params}`, {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: segments, usage } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/segments",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"with_counts": "true"},
)
segments = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('segments', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['with_counts' => 'true'],
]);
$segments = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "object": "segment",
      "id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
      "name": "Pro customers renewing soon",
      "description": "Pro and Enterprise plans that renew in the next 30 days.",
      "audience_ids": ["aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a"],
      "conditions": {
        "match": "all",
        "groups": [
          {
            "match": "all",
            "rules": [
              { "field": "custom_fields.plan", "operator": "in", "value": ["pro", "enterprise"] },
              { "field": "custom_fields.renews_on", "operator": "in_next_days", "value": 30 }
            ]
          }
        ]
      },
      "tracked": true,
      "tracking": {
        "status": "active",
        "synced_at": "2026-10-18T00:30:04.211000+00:00"
      },
      "contacts_count": 412,
      "subscribed_count": 398,
      "created_at": "2026-10-02T09:14:03.551000+00:00",
      "updated_at": "2026-10-02T09:14:03.551000+00:00"
    }
  ],
  "total_records": 1,
  "usage": {
    "used": 1,
    "limit": 10,
    "tracking_allowed": true
  },
  "next_page_url": null,
  "previous_page_url": null
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/list/

## Segment löschen — DELETE /segments/{id}

> Löschen Sie ein Segment. Kampagnenentwürfe, die an das Segment senden, verlieren es; Entwürfe, die es ausschließen, können erst senden, wenn Sie den Ausschluss ersetzen. Geplante oder sendende Kampagnen und Automatisierungen, die das Segment verwenden, verhindern das Löschen. Alpha: nur für das Emailit-Team zugänglich.

# Segment löschen

Löscht ein Segment. Erfordert einen API-Schlüssel mit dem Scope `full`.

- Ein Segment, das eine Kampagne verwendet, während sie geplant ist, in der Warteschlange steht, gesendet oder getestet wird, lässt sich nicht löschen. Ändern Sie zuerst die Empfänger der Kampagne.
- Ein Segment lässt sich nicht löschen, solange eine nicht gelöschte Automatisierung, egal in welchem Status, es verwendet: in einem Trigger **Added to segment** oder **Removed from segment**, in einem Ziel, einem Schritt **Wait until** oder einer Ausstiegsbedingung zu diesen Events oder in einer Regel **Segment** einer Bedingung. Ändern Sie zuerst diese Automatisierungen.
- Kampagnenentwürfe, die an das Segment senden, verlieren es aus ihren Empfängern, und `removed_from_campaigns` gibt an, wie viele es sind. Entwürfe, die das Segment ausschließen, behalten den Ausschluss und lassen sich daher erst senden, wenn Sie ihn ersetzen: Ohne ihn würden sie an die Personen gehen, die Sie ausschließen wollten. Gesendete, stornierte und archivierte Kampagnen behalten den Verweis als Verlauf.
- Bei einem Segment mit Tracking werden auch seine gespeicherten Mitglieder und sein Wachstumsverlauf gelöscht.

`DELETE /segments/{id}`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Pfadparameter

- `id` (string, erforderlich): Die ID des Segments (`seg_…`).

## Rückgabe

- `object` (string): Immer `segment`.

- `id` (string): ID des gelöschten Segments.

- `name` (string): Sein Name.

- `deleted` (boolean): Immer `true`.

- `removed_from_campaigns` (integer): Anzahl der Kampagnenentwürfe, die nicht mehr an das Segment senden.

| Status | Wann |
| --- | --- |
| `404` | Das Segment existiert nicht. |
| `409` | Eine Kampagne, die geplant ist, in der Warteschlange steht, gerade sendet oder getestet wird, verwendet das Segment, oder eine Automatisierung startet damit. Die Meldung nennt sie. |

**Anfrage** `DELETE /segments/{id}`

**cURL**

```bash
curl -X DELETE https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const result = await res.json();
```

**Python**

```python
import os, requests

r = requests.delete(
    "https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
result = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->delete('segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$result = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "segment",
  "id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
  "name": "Pro customers renewing soon",
  "deleted": true,
  "removed_from_campaigns": 1
}
```

**409 Kampagnen**

```json
{
  "error": "This segment is used by campaigns that are scheduled or sending: October launch. Change their recipients first.",
  "message": "This segment is used by campaigns that are scheduled or sending: October launch. Change their recipients first."
}
```

**409 Automatisierungen**

```json
{
  "error": "This segment is used by automations: Renewal reminder. Change their triggers, conditions or exit conditions first.",
  "message": "This segment is used by automations: Renewal reminder. Change their triggers, conditions or exit conditions first."
}
```

**404**

```json
{
  "error": "Segment not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/delete/

## Kontakte eines Segments auflisten — GET /segments/{id}/contacts

> Listen Sie die Kontakte auf, die einem Segment gerade entsprechen, mit Suche, denselben Filtern wie beim Auflisten von Kontakten und bei Segmenten mit Tracking dem Zeitpunkt, zu dem jeder Kontakt beigetreten ist. Alpha: nur für das Emailit-Team zugänglich.

# Kontakte eines Segments auflisten

Gibt die Kontakte zurück, die dem Segment zum Zeitpunkt des Aufrufs entsprechen, die neuesten zuerst. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /segments/{id}/contacts`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Pfadparameter

- `id` (string, erforderlich): Die ID des Segments (`seg_…`).

## Query-Parameter

- `page` (integer): Seitennummer, beginnend bei 1.

- `limit` (integer): Kontakte pro Seite, von 1 bis 100.

- `search` (string): Abgleich mit einem Teil der E-Mail-Adresse, des Vornamens oder des Nachnamens, ohne Beachtung der Groß-/Kleinschreibung.

- `match`, `order`, `direction`: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

### Filterschlüssel

Die Kontakte eines Segments akzeptieren dieselben Filter- und Sortierschlüssel wie [Kontakte auflisten](/de/docs/api-reference/contacts/list/), angewendet zusätzlich zum Segment, zum Beispiel `email.ends_with=acme.com`.

Filter- und Sortierschlüssel: siehe [Filtern und Sortieren](https://emailit.com/de/docs/api-reference/filtering/).

## Rückgabe

- `data` (object[]): Kontakte auf dieser Seite, jeweils mit `object`, `id`, `email`, `first_name`, `last_name`, `custom_fields`, `unsubscribed`, `audiences` (`id`, `name`, `subscribed`), `created_at` und `updated_at`. Kontakte eines [Segments mit Tracking](/de/docs/segments/tracked/) haben außerdem `joined_at`.

- `data[].joined_at` (string | null): Nur bei Segmenten mit Tracking: Zeitpunkt, zu dem die aktuelle Mitgliedschaft des Kontakts im Segment begann. `null`, bis das Tracking den Kontakt erfasst hat, zum Beispiel direkt nachdem er dem Segment zu entsprechen begann, während das Segment `syncing` ist oder während das Tracking `paused` ist.

- `total_records` (integer): Anzahl der Kontakte, die dem Segment, der Suche und den Filtern entsprechen.

- `subscribed_count` (integer): An wie viele davon Kampagnen senden können: nicht global abgemeldet und bei mindestens einer Kontaktliste angemeldet.

- `next_page_url` (string | null): Pfad der nächsten Seite oder `null` auf der letzten Seite. Er enthält `page`, `limit` und `search`; fügen Sie Ihre Filter erneut hinzu, wenn Sie ihm folgen.

- `previous_page_url` (string | null): Pfad der vorherigen Seite oder `null` auf der ersten Seite.

Gibt `404` zurück, wenn das Segment nicht existiert.

**Anfrage** `GET /segments/{id}/contacts`

**cURL**

```bash
curl -G https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/contacts \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d email.ends_with=acme.com
```

**Node.js**

```javascript
const params = new URLSearchParams({ 'email.ends_with': 'acme.com' });
const res = await fetch(
  `https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/contacts?${params}`,
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: contacts } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/contacts",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"email.ends_with": "acme.com"},
)
contacts = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/contacts', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['email.ends_with' => 'acme.com'],
]);
$contacts = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "object": "contact",
      "id": "con_2nYs7Ab3Kd9Lm1Qw5Er8Ty2Ui4o",
      "email": "ada@acme.com",
      "first_name": "Ada",
      "last_name": "Lovelace",
      "custom_fields": {
        "plan": "pro",
        "renews_on": "2026-10-20"
      },
      "unsubscribed": false,
      "audiences": [
        {
          "id": "aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a",
          "name": "Customers",
          "subscribed": true
        }
      ],
      "created_at": "2026-03-11T08:00:00.000000+00:00",
      "updated_at": "2026-09-30T16:42:10.000000+00:00",
      "joined_at": "2026-10-03T00:30:02.874000+00:00"
    }
  ],
  "total_records": 1,
  "subscribed_count": 1,
  "next_page_url": null,
  "previous_page_url": null
}
```

**404**

```json
{
  "error": "Segment not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/contacts/

## Wachstum eines Segments abrufen — GET /segments/{id}/growth

> Tägliche Mitgliederzahlen, Beitritte und Austritte eines Segments mit Tracking, eine Zeile pro UTC-Tag für bis zu 365 Tage. Alpha: nur für das Emailit-Team zugänglich.

# Wachstum eines Segments abrufen

Gibt den Verlauf eines [Segments mit Tracking](/de/docs/segments/tracked/) zurück: eine Zeile pro UTC-Tag, die ältesten zuerst, bis einschließlich heute. Das sind die Daten hinter dem Diagramm **Growth** auf der Seite des Segments. Erfordert einen API-Schlüssel mit dem Scope `full`.

Der Verlauf beginnt, wenn das Tracking beginnt. Kontakte, die bei der ersten Zählung nach dem Erstellen des Segments oder nach dem Fortsetzen des Trackings erfasst werden, zählen als Mitglieder, aber nicht als Beitritte.

`GET /segments/{id}/growth`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Pfadparameter

- `id` (string, erforderlich): Die ID des Segments (`seg_…`).

## Query-Parameter

- `days` (integer): Anzahl der zurückgegebenen Tage, von 1 bis 365, bis einschließlich heute.

## Rückgabe

- `object` (string): Immer `segment_growth`.

- `segment_id` (string): Die ID des Segments.

- `data` (object[]): Eine Zeile pro Tag.

- `data[].date` (string): Der UTC-Tag, `YYYY-MM-DD`.

- `data[].members_count` (integer | null): Mitglieder am Ende des Tages oder die neueste Zählung für heute. Tage ohne neue Zählung übernehmen den vorherigen Wert, zum Beispiel während das Tracking pausiert ist. `null` vor Beginn des Trackings.

- `data[].joined_count` (integer): Kontakte, die an diesem Tag dem Segment beigetreten sind.

- `data[].left_count` (integer): Kontakte, die an diesem Tag das Segment verlassen haben.

| Status | Wann |
| --- | --- |
| `404` | Das Segment existiert nicht. |
| `422` | Das Segment hat kein Tracking. |

**Anfrage** `GET /segments/{id}/growth`

**cURL**

```bash
curl -G https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/growth \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -d days=7
```

**Node.js**

```javascript
const res = await fetch(
  'https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/growth?days=7',
  { headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` } },
);
const { data: days } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/growth",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    params={"days": 7},
)
days = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('segments/seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p/growth', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'query' => ['days' => 7],
]);
$days = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "object": "segment_growth",
  "segment_id": "seg_2nYs9Kd1Lq3vB8wXcE4fT7uRm0p",
  "data": [
    { "date": "2026-10-12", "members_count": null, "joined_count": 0, "left_count": 0 },
    { "date": "2026-10-13", "members_count": 380, "joined_count": 0, "left_count": 0 },
    { "date": "2026-10-14", "members_count": 391, "joined_count": 14, "left_count": 3 },
    { "date": "2026-10-15", "members_count": 391, "joined_count": 0, "left_count": 0 },
    { "date": "2026-10-16", "members_count": 402, "joined_count": 12, "left_count": 1 },
    { "date": "2026-10-17", "members_count": 405, "joined_count": 6, "left_count": 3 },
    { "date": "2026-10-18", "members_count": 412, "joined_count": 9, "left_count": 2 }
  ]
}
```

**422**

```json
{
  "error": "Growth is recorded for tracked segments only.",
  "message": "Growth is recorded for tracked segments only."
}
```

**404**

```json
{
  "error": "Segment not found"
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/growth/

## Segmentvorschau abrufen — POST /segments/preview

> Zählen Sie die Kontakte, die eine Segmentdefinition enthalten würde, und rufen Sie eine Stichprobe davon ab, ohne die Definition zu speichern. Alpha: nur für das Emailit-Team zugänglich.

# Segmentvorschau abrufen

Prüft eine Segmentdefinition, ohne sie zu speichern: Gibt zurück, wie viele Kontakte ihr entsprechen, und eine Stichprobe davon. Die Definition wird wie bei [Segment erstellen](/de/docs/api-reference/segments/create/) validiert, und eine Vorschau zählt nicht zum Segmentlimit des Tarifs. Erfordert einen API-Schlüssel mit dem Scope `full`.

`POST /segments/preview`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Body-Parameter

- `audience_ids` (string[]): IDs der Kontaktlisten, aus denen das Segment schöpfen würde. Leer oder weggelassen bedeutet alle Kontakte.

- `conditions` (object): Die Regeln. Siehe [Segment erstellen](/de/docs/api-reference/segments/create/#conditions).

- `limit` (integer): Anzahl der Beispielkontakte, von 1 bis 25.

## Rückgabe

- `object` (string): Immer `segment_preview`.

- `audience_ids` (string[]): Die Kontaktlisten der Quelle, ohne Duplikate.

- `conditions` (object): Die Regeln, so wie sie gespeichert würden: Ein flaches `{ match, rules }` wird zu einer Gruppe, und leere Gruppen werden verworfen.

- `contacts_count` (integer): Kontakte, die der Definition entsprechen.

- `subscribed_count` (integer): An wie viele davon Kampagnen senden können.

- `contacts` (object[]): Die neuesten passenden Kontakte, in derselben Form wie bei [Kontakte eines Segments auflisten](/de/docs/api-reference/segments/contacts/).

Gibt `422` mit `errors`, geschlüsselt nach Feldpfad, zurück, wenn die Definition ungültig ist.

**Anfrage** `POST /segments/preview`

**cURL**

```bash
curl -X POST https://api.emailit.com/v2/segments/preview \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "conditions": { "rules": [{ "field": "email_domain", "operator": "equals", "value": "acme.com" }] },
    "limit": 5
  }'
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments/preview', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.EMAILIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    conditions: { rules: [{ field: 'email_domain', operator: 'equals', value: 'acme.com' }] },
    limit: 5,
  }),
});
const preview = await res.json();
```

**Python**

```python
import os, requests

r = requests.post(
    "https://api.emailit.com/v2/segments/preview",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
    json={
        "conditions": {"rules": [{"field": "email_domain", "operator": "equals", "value": "acme.com"}]},
        "limit": 5,
    },
)
preview = r.json()
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->post('segments/preview', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
    'json' => [
        'conditions' => ['rules' => [['field' => 'email_domain', 'operator' => 'equals', 'value' => 'acme.com']]],
        'limit' => 5,
    ],
]);
$preview = json_decode($response->getBody(), true);
```

**200**

```json
{
  "object": "segment_preview",
  "audience_ids": [],
  "conditions": {
    "match": "all",
    "groups": [
      {
        "match": "all",
        "rules": [
          { "field": "email_domain", "operator": "equals", "value": "acme.com" }
        ]
      }
    ]
  },
  "contacts_count": 8,
  "subscribed_count": 8,
  "contacts": [
    {
      "object": "contact",
      "id": "con_2nYs7Ab3Kd9Lm1Qw5Er8Ty2Ui4o",
      "email": "ada@acme.com",
      "first_name": "Ada",
      "last_name": "Lovelace",
      "custom_fields": {
        "plan": "pro",
        "renews_on": "2026-10-20"
      },
      "unsubscribed": false,
      "audiences": [
        {
          "id": "aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a",
          "name": "Customers",
          "subscribed": true
        }
      ],
      "created_at": "2026-03-11T08:00:00.000000+00:00",
      "updated_at": "2026-09-30T16:42:10.000000+00:00"
    }
  ]
}
```

**422**

```json
{
  "message": "Validation failed. conditions.groups.0.rules.0.operator: \"greater_than\" does not apply to Email domain.",
  "errors": {
    "conditions.groups.0.rules.0.operator": [
      "\"greater_than\" does not apply to Email domain."
    ]
  }
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/preview/

## Segmentfelder auflisten — GET /segments/fields

> Listen Sie die Kontaktfelder, eigenen Felder und Kontaktlisten auf, die Segmentregeln verwenden können, mit den Operatoren und Werten, die jedes Feld akzeptiert. Alpha: nur für das Emailit-Team zugänglich.

# Segmentfelder auflisten

Gibt die Felder zurück, die Segmentregeln in diesem Workspace verwenden können: die Kontaktfelder, jedes eigene Feld (typisiert nach seinem Feldtyp), die Mitgliedschaft in Kontaktlisten, Kaufdaten und das Engagement mit Kampagnen. Erfordert einen API-Schlüssel mit dem Scope `full`.

`GET /segments/fields`

> **Segmente sind in der Alpha:** Segmente stehen nur dem Emailit-Team offen, solange wir sie testen. Andere Anfragen, auch jede Anfrage mit einem API-Schlüssel, geben `403` mit `error: "segments_alpha"` zurück. Siehe [Wer Segmente nutzen kann](/de/docs/segments/#who-can-use-segments).

## Rückgabe

- `data` (object[]): Ein Eintrag pro Feld.

- `data[].key` (string): Der Wert, den Sie als `field` einer Regel verwenden, zum Beispiel `email_domain` oder `custom_fields.plan`.

- `data[].label` (string): Anzeigename. Bei eigenen Feldern der Name des eigenen Felds.

- `data[].type` (string): `string`, `number`, `date`, `datetime`, `boolean`, `enum`, `multi`, `audience`, `metric`, `moment`, `purchase`, `view`, `cart`, `coupon` oder `campaign_activity`. Siehe [Segment erstellen](/de/docs/api-reference/segments/create/#fields). Aktivitätsfelder wie `purchased` nehmen ein Objekt als Wert an, siehe [Aktivitätsregeln](/de/docs/api-reference/segments/create/#activity-rules).

- `data[].group` (string): `contact`, `custom_fields`, `audiences`, `commerce` (Kaufdaten) oder `engagement` (Kampagnenaktivität).

- `data[].operators` (string[]): Operatoren, die das Feld akzeptiert.

- `data[].values` (object[]): Erlaubte Werte als `value` und `label`: die Optionen eigener Felder vom Typ Auswahl und Mehrfachauswahl, `subscribed` und `unsubscribed` für `status` sowie die Kontaktlisten des Workspaces für `audience`. Fehlt bei anderen Feldern.

**Anfrage** `GET /segments/fields`

**cURL**

```bash
curl https://api.emailit.com/v2/segments/fields \
  -H "Authorization: Bearer $EMAILIT_API_KEY"
```

**Node.js**

```javascript
const res = await fetch('https://api.emailit.com/v2/segments/fields', {
  headers: { Authorization: `Bearer ${process.env.EMAILIT_API_KEY}` },
});
const { data: fields } = await res.json();
```

**Python**

```python
import os, requests

r = requests.get(
    "https://api.emailit.com/v2/segments/fields",
    headers={"Authorization": f"Bearer {os.environ['EMAILIT_API_KEY']}"},
)
fields = r.json()["data"]
```

**PHP**

```php
$client = new GuzzleHttp\Client(['base_uri' => 'https://api.emailit.com/v2/']);

$response = $client->get('segments/fields', [
    'headers' => ['Authorization' => 'Bearer ' . getenv('EMAILIT_API_KEY')],
]);
$fields = json_decode($response->getBody(), true)['data'];
```

**200**

```json
{
  "data": [
    {
      "key": "email",
      "label": "Email",
      "type": "string",
      "group": "contact",
      "operators": ["equals", "not_equals", "contains", "not_contains", "starts_with", "ends_with", "in", "not_in", "is_set", "is_not_set"]
    },
    {
      "key": "status",
      "label": "Subscription status",
      "type": "enum",
      "group": "contact",
      "operators": ["equals", "not_equals"],
      "values": [
        { "value": "subscribed", "label": "Subscribed" },
        { "value": "unsubscribed", "label": "Unsubscribed" }
      ]
    },
    {
      "key": "audience",
      "label": "Audience",
      "type": "audience",
      "group": "audiences",
      "operators": ["in", "not_in"],
      "values": [
        { "value": "aud_2nYs8Qm4Hc1Zx7Vb3Ne6Tg9Lk2a", "label": "Customers" }
      ]
    },
    {
      "key": "purchased",
      "label": "Purchased",
      "type": "purchase",
      "group": "commerce",
      "operators": [
        "has",
        "has_not"
      ]
    },
    {
      "key": "custom_fields.renews_on",
      "label": "Renews on",
      "type": "date",
      "group": "custom_fields",
      "operators": ["on", "before", "after", "between", "in_last_days", "more_than_days_ago", "in_next_days", "is_set", "is_not_set"]
    }
  ]
}
```

---
Quelle: https://emailit.com/de/docs/api-reference/segments/fields/