# Fullstack experiments

URL: https://docs.ablyft.com/de/developers/application-integration/fullstack/

> Führe Experiments auf deinem Server oder in deiner eigenen Anwendung aus, indem du eine JSON-Konfigurationsdatei liest, die ABlyft veröffentlicht.



Mit dem Browser-Snippet entscheidet ABlyft im Browser des Visitors, welche Variation angezeigt wird. **FullStack** ist für Fälle,
in denen die Entscheidung oder die Änderung selbst woanders stattfinden muss: auf deinem Server, in deinen Backend-Templates oder in
deiner eigenen App. Typische Beispiele sind Suchranking, Preis- oder Sortierlogik.

Dafür veröffentlicht ABlyft eine **Config file** mit deinen laufenden Experiments, Variations und dem Targeting. Deine Anwendung
liest diese Datei, wendet deinen eigenen Variation-Code an und meldet Conversions zurück.

> **Prüfe zuerst die Verfügbarkeit:** FullStack ist nur sichtbar, wenn dein Plan es enthält, und der Abschnitt **General Settings** auf der FullStack-Einstellungsseite
> ist in der App als deprecated markiert. Bevor du eine neue serverseitige Integration baust, kontaktiere den ABlyft-Support, um
> den Integrationsweg abzustimmen (Config file, Feature Experimentation API oder SDK).

## So funktioniert es

1. Du aktivierst FullStack für das **Project** und für jedes **Experiment**, das es nutzen soll.
2. Du erstellst **Variations vom Typ FullStack** und gibst ihnen **Properties** (Key-Value-Paare).
3. Beim Publishing schreibt ABlyft die **Config file** an eine öffentliche URL.
4. Deine Anwendung lädt die Datei, entscheidet, welche Variation ein Visitor erhält, und wendet die Properties der Variation an.
5. Deine Anwendung sendet Goals an ABlyft zurück, sodass Results wie bei jedem anderen Experiment erscheinen.

## Schritt 1: FullStack für das Project aktivieren

Gehe in deinem Project zu **Settings → FullStack**. Der Menüeintrag erscheint nur, wenn dein Plan FullStack enthält.

| Einstellung                                            | Beschreibung                                                                                                                                                                                                                                       |
| ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fullstack enabled** (Toggle in **General Settings**) | Aktiviert die FullStack Config file und schaltet zusätzliche Optionen für Experiments und Variations frei.                                                                                                                                         |
| **Secret prefix**                                      | Ein kurzer zufälliger Präfix (bis zu 11 Zeichen), der Teil der URL der Config file wird, damit sie schwer zu erraten ist. Dringend empfohlen, wenn die Datei öffentlich zugänglich ist. Mit **Re-generate secure secret** erzeugst du einen neuen. |
| **Cache expiration (ttl)**                             | Wie lange die Config file gecacht werden darf: kein Caching, 1 (Standard), 2 oder 5 Minuten. Nur lesbar, wende dich zur Änderung an den ABlyft-Support.                                                                                            |

> **Das Neugenerieren des Secrets ändert die URL:** Ein neuer Secret prefix ändert die URL der Config file. Aktualisiere sie überall, wo du die Datei referenzierst.

Die rechte Seite der Seite zeigt die **Config File Implementation**: die **Config file URL** (zum Kopieren anklicken), die
**Project ID**, **File size**, **Project revision** und **Last published**. Wenn du Environments mit aktiviertem
**Create a sub-snippet** hast, listet **Sub Config Files** eine zusätzliche Datei pro Environment auf. Jede enthält nur die Experiments dieses
[Environments](https://docs.ablyft.com/de/developers/installation/environments/).

Die URL hat diese Form:

```text
https://fullstack.ablyft.com/c/{secretPrefix}-{projectId}.json
```

Für eine Environment-Datei wird vor `.json` ein `-{environment API name}` angehängt.

## Schritt 2: FullStack für ein Experiment aktivieren

1. Öffne das Experiment und seine Einstellungen (Zahnrad-Symbol).
2. Aktiviere im Abschnitt **General** den Schalter **Enable FullStack for this experiment**. Der Toggle ist nur sichtbar, wenn
   FullStack für das Project aktiviert ist. Das Experiment wird zur Config file hinzugefügt, und der Variation-Typ
   **FullStack** wird verfügbar.

## Schritt 3: FullStack-Variations erstellen

1. Erstelle im Experiment eine Variation und wähle den Typ **FullStack**.
2. Füge im Abschnitt **FullStack** **Variation properties** hinzu: Key-Value-Paare, die deine Anwendung erhält, zum Beispiel
   `color = blue` oder `price_variant = premium`.
3. Speichere.

Die Properties werden als `data` der Variation in der Config file ausgeliefert. Eine FullStack-Variation kann außerdem JS- und
CSS-Code haben, siehe [Custom JavaScript](https://docs.ablyft.com/de/developers/application-integration/custom-javascript/).

## Was die Config file enthält

Die Datei wird bei jedem Publishing des Projects neu erzeugt. Sie enthält alle Experiments des Projects mit dem
Status **running** oder **preview** und für jedes Experiment seine Variations, Audiences, Environments und Pages.

```json
{
  "project_id": 12345678,
  "project_name": "example.com",
  "debug_enabled": false,
  "published_at": "2026-01-15T10:30:00.000000Z",
  "stale_experiment_ids": [],
  "experiments": [
    {
      "id": 87654321,
      "status": "running",
      "api_name": "pricing-test",
      "name": "Pricing test",
      "traffic_allocation": 100,
      "audiences_match_type": "any",
      "metadata": [],
      "variations": [
        {
          "id": 11111111,
          "api_name": "original",
          "name": "Original",
          "baseline": true,
          "traffic_allocation": 50,
          "metadata": [],
          "data": {}
        },
        {
          "id": 22222222,
          "api_name": "premium",
          "name": "Premium price",
          "baseline": false,
          "traffic_allocation": 50,
          "metadata": [],
          "data": { "price_variant": "premium" }
        }
      ],
      "audiences": [],
      "environments": [],
      "pages": []
    }
  ],
  "exclusion_groups": [],
  "goals": [
    { "id": 33333333, "api_name": "purchase", "type": "revenue" }
  ]
}
```

Die Werte sind beispielhaft; die Feldnamen sind die, die ABlyft schreibt. Hinweise:

* `audiences` enthalten die Targeting-Definition jeder Audience, `pages` enthalten `id` und `api_name`.
* `goals` listet die Goals auf, die von den exportierten Experiments verwendet werden, mit `id`, `api_name` und `type`.
* `exclusion_groups` werden mit ihren Einträgen exportiert (`experiment_id`, `traffic`).
* `stale_experiment_ids` listet archivierte Experiments auf (in den letzten 6 Monaten archiviert, mit Participants).
  Das unterstützt das Aufräumen gespeicherter Visitor-Zuweisungen.

## Was deine Anwendung tut

ABlyft veröffentlicht die Datei, die Logik drumherum liegt in deiner Anwendung:

1. **Lade** die Config file (cache sie für die Dauer der Cache Expiration).
2. **Entscheide** für jeden Visitor, ob ein Experiment greift (Pages, Audiences, Environments, Traffic Allocation),
   und **weise eine Variation zu** anhand der Traffic Allocation der Variations. Speichere die Zuweisung pro Visitor, damit der
   Visitor immer dieselbe Variation sieht.
3. **Wende** die Variation an, anhand ihrer `data`-Properties.
4. **Melde Goals** an ABlyft zurück.

Für den letzten Punkt und für die Entscheidungslogik kontaktiere den ABlyft-Support, um die aktuellen Integrationsoptionen für deinen
Account zu erfahren. Die Dokumentation der *Feature Experimentation API* beschreibt dafür zwei HTTPS-Endpoints:
`https://fe-api.ablyft.com/v1/decide` (welche Variation erhält ein User?) und `https://fe-api.ablyft.com/v1/track`
(Goals senden). Aufrufe werden mit einem API-Token authentifiziert (`Authorization: Bearer [token]`), und die aktuelle
Zuweisung des Visitors wird als `user.bucketing` übergeben. Diese API wird auf Anfrage angeboten, bestätige also die Verfügbarkeit beim ABlyft-Support,
bevor du darauf aufbaust.

## FullStack- und Browser-Experiments mischen (hybrid)

Du kannst Browser-Experiments und serverseitige Experiments für dieselben Visitors ausführen. Wichtig ist, dass der Visitor
**eine** konsistente Zuweisung hat. Im Browser speichert ABlyft sie in `ablyft_exps` im konfigurierten Storage (siehe [Storage & privacy](https://docs.ablyft.com/de/developers/consent-and-security/storage-and-privacy/)). Auf der API-Seite sind es dieselben
Informationen als `user.bucketing`. Stimmen beide überein, bleiben Tracking und Visitor-Erlebnis korrekt. Du kannst die
Zuweisung im Browser mit `ablyft.get('bucketing')` auslesen, siehe die
[`get()`-Referenz](https://docs.ablyft.com/de/developers/reference/javascript-api/get/#bucketing).

## Nächste Schritte

- [Environments](https://docs.ablyft.com/de/developers/installation/environments/): Sub Config Files pro Environment.
- [Tracking & events](https://docs.ablyft.com/de/developers/tracking-and-events/): Goals und Events im Browser.
- [REST API](https://docs.ablyft.com/de/developers/reference/rest-api/): Verwalte Projects und Experiments per API.

