# Playground

> URL: https://foura.ai/de/docs/dashboard/playground
> Updated: 2026-11-11
> Index: https://foura.ai/llms.txt

Im Playground (Seitenleiste > Playground) kannst du Live-API-Requests mit deinem echten Key ausführen, ohne Code zu schreiben. Es ist der schnellste Weg, eine neue Zielseite zu testen, eine schwierige Response zu debuggen oder Auto, Single, Proxy und Browser direkt miteinander zu vergleichen.

Öffne ihn unter [foura.ai/dashboard#playground](https://foura.ai/dashboard#playground).

## Funktionen

Ein Formular. Vier Engines. Echter Traffic.

- **Auto**: Smart Fetch. Du übergibst eine URL plus eine `validate`-Regel, und FourA wählt den günstigsten funktionierenden Pfad.
- **Single**: Direkter HTTP-Fetch mit realistischen, browserähnlichen Wire-Eigenschaften
- **Proxy**: Verwalteter Fetch mit rotierenden Proxys, optional auf zielrelevante Länder beschränkt
- **Browser**: Öffnet die URL in einer Chrome-Browser-Instanz für JS-gerenderte Websites

Requests laufen über den API-Key, den du oben auf der Seite auswählst. Die Nutzung wird wie bei einem Production-Call auf das Kontingent dieses Keys angerechnet. Achte also darauf, dein Kontingent beim Testen nicht aufzubrauchen.

## Key auswählen

Das Dropdown-Menü für den API-Key listet jeden aktiven Key auf, den du verwenden kannst: deine eigenen unter **Meine Keys**, gefolgt von einer Gruppe für jede Organisation, der du angehörst. Jedes Mitglied kann den Key einer Organisation ausführen, und ein Request darüber wird dem Plan des Organisationseigners angerechnet. Wähle den Key, über den der Request abgerechnet werden soll. Wenn du noch keine aktiven Keys hast, führt dich ein Link direkt zur Seite **API-Keys**, um einen zu erstellen.

## Modus auswählen

Eine obere **Modus**-Zeile schaltet zwischen **Auto** und den manuellen Engines um. Wenn Auto ausgewählt ist, wechselt das Formular zur reduzierten Auto-Oberfläche (URL plus `validate` plus einige Optionen). Beide Zeilen werden immer angezeigt: **Modus:** Auto, und **Endpoint:** **Single**, **Proxy**, **Browser**. Die Auswahl einer Option hebt die andere auf. Durch das Wechseln von Endpoints ändern sich die sichtbaren Felder und die Engine, an die der Request gesendet wird. Die aktuelle Auswahl bleibt beim Neuladen der Seite erhalten.

| Modus | Typischer Einsatzzweck |
|------|----------------|
| Auto | Neues Ziel oder Website mit gemischten Schutzmechanismen. Auto wählt den günstigsten Pfad und merkt sich, was funktioniert. |
| Single | Schneller HTTP-Fetch. Die beste erste Wahl für einen bekannten Host. |
| Proxy | Gleicher Fetch mit automatischer Proxy-Rotation. Setze `exitCountries`, wenn du ein bestimmtes Land vorgeben musst. |
| Browser | Lädt die Seite in einer Chrome-Browser-Instanz. Verwende dies, wenn Daten erst nach der Ausführung von JavaScript erscheinen. |

## Request zusammenstellen

### URL-Zeile

Die oberste Zeile enthält die HTTP-Methode (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS), die Ziel-URL und den Button **Senden**. Single, Proxy und Auto unterstützen jede Methode. Browser ignoriert die Methode (Chrome nutzt für die Navigation immer GET) sowie den Body.

### Request-Tabs

Unter der URL-Zeile kannst du über fünf Tabs alle weiteren Details angeben:

| Tab | Was gesteuert wird |
|-----|--------------------|
| UI | Formularfelder für Timeouts, Redirects, Flags, Proxy, browserspezifische Optionen und Validierungsregeln |
| Body | Freitext-Body für POST- / PUT- / PATCH-Requests |
| Headers | Benutzerdefinierte Request-Header als Key-Value-Paare |
| Cookies | Ein Cookie-Jar pro Host in diesem Browser. **Use jar** hängt passende Cookies an den Request an und **Save response cookies** speichert Cookies aus Responses. Beide sind standardmäßig aktiv, und der Tab zeigt eine Vorschau der gesendeten Cookies |
| Raw | Die exakte JSON-Payload, die gesendet wird, als schreibgeschützte Vorschau mit **Copy JSON**, darunter der cURL-Befehl zur Reproduktion |

Alles, was du in UI / Body / Headers / Cookies änderst, wird direkt in Raw übernommen. Du kannst in Raw nichts eingeben: Bearbeite den Request in den anderen Tabs. Ein roter Punkt markiert Tabs oder einklappbare Abschnitte mit Werten, die von den Engine-Defaults abweichen, damit du deine Anpassungen sofort erkennst.

### Abschnitte des UI-Bereichs

Der UI-Tab unterteilt Einstellungen in einklappbare Abschnitte. Leere Felder nutzen die Schema-Defaults der Engine. Abschnitte, die für den aktuellen Mode nicht gelten, werden ausgeblendet.

- **Timeouts**: `timeout_ms`, `connect_timeout_ms`, `accept_timeout_ms`, `server_response_timeout_ms`, `dns_cache_timeout_sec`. Browser und Auto bieten nur `timeout_ms` (bei Auto das Gesamtbudget).
- **Redirects**: aktivieren und `followRedirects` festlegen (0-20). Single und Proxy. Browser folgt Redirects automatisch.
- **Flags**: `unblocker` für Single, Proxy und Browser (`unblocker` im Browser schliesst die von einer Seite geforderten Prüfungen ab); `tryJsonData` und `returnBuffer` für Single und Proxy. Auto bietet stattdessen `forceProxy` und `returnSession`.
- **Proxy**: Wähle eine bestimmte Proxy-ID für Single oder Browser, oder setze `maxTries`, das äussere Proxy-Timeout, `exitCountries`, `exitClass` und `ignoreProxies` für die Proxy-Engine. Auto bietet zusätzlich `ignoreProxies` und `exitClass`. Das Auswahlfeld `exitClass` hat drei Zustände: Nicht gesetzt sendet überhaupt kein Feld, `standard` bestimmt den Standard-Pool und `premium` lässt den Request zu einem Premium-Exit eskalieren, wenn der Standard-Pool überlastet ist. Nicht gesetzt und `standard` verbleiben beide im Standard-Pool; ein erfolgreicher Request, der eine Klasse angibt, gibt `exitClass` zurück. Premium erfordert einen Tarif, der Premium-Exits enthält: siehe [exitClass](https://foura.ai/docs/api/endpoints#exitclass).
- **Browser profile**: Drei kaskadierende Dropdowns, **os**, **browser** und **version**, listen auf, was FourA tatsächlich darstellen kann. Sie erscheinen im Modus Single und Proxy. Lass sie leer, um das neueste Chrome zu nutzen. Jedes Auswahlfeld schränkt die anderen beiden ein, sodass eine ungültige Kombination niemals angezeigt wird. Der Bereich erfordert aktiviertes `unblocker`: Ist es deaktiviert, werden keine Browser-Header gesendet, ein Profil würde nur unvollständig angewendet und die API lehnt den Request stattdessen ab.
- **Browser**: Reine Browser-Optionen wie `checkStatus` und `checkText`.
- **Validate**: **status accept** und **status fail** akzeptieren kommagetrennte Statuscodes (`validate.status`), und **body accept** sowie **body fail** akzeptieren Substrings mit durch `|` getrennten Alternativen (`validate.data`). Verfügbar für Single, Proxy und Auto. Browser nutzt stattdessen `checkStatus` und `checkText`. Das Formular enthält kein Feld für Header-Regeln (`validate.headers`).

Sobald ein Durchlauf einen funktionierenden Proxy zurückgibt, erscheint am Ende des UI-Tabs der Bereich **Working proxies**. Er listet bis zu 20 Proxy-IDs auf, die neuesten zuerst, jeweils mit Exit-Land und Zeitstempel. **use** übernimmt einen Eintrag in das Feld `proxy` bei Single oder Browser (die Proxy-Engine ermittelt ihren eigenen), und **×** entfernt ihn aus der Liste.

### Exit-Länder-Scoping (Proxy-Modus)

Das Feld **exitCountries** bei Proxy akzeptiert eine kommagetrennte Liste von zweistelligen, für das Ziel sichtbaren Ländercodes (`CZ, GB`). Werte werden beim Absenden getrimmt, in Großbuchstaben umgewandelt und dedupliziert. Die Auswahl aus dem Standard-Pool ist eine strikte Allowlist: Proxys mit unbekanntem Exit werden ausgeschlossen und der Pool weicht nie auf ein anderes Land aus. Ein Premium-Exit folgt der Liste ebenfalls. Wenn **exitClass** auf `premium` gesetzt ist, erfolgt ein Premium-Exit über eines der aufgelisteten Länder, und ein Land, für das der Standard-Pool keine Ressourcen hat, nutzt dortige Premium-Exits. Ohne `premium` gibt ein Pool ohne Treffer `code: "no_eligible_proxy"` zurück, wobei der angeforderte Scope in `details.exitCountries` widergespiegelt wird. Behalte den Scope bei und versuche es später erneut.

Wenn ein Proxy-Aufruf mit Scoping erfolgreich ist, zeigt die Response-Leiste `exit <CODE>` neben der Proxy-ID an, damit du prüfen kannst, ob das bediente Land deiner Anfrage entspricht.

### Exit-Standort (Proxy-Modus)

Die Gruppe **Exit location** bei Proxy bestimmt, von wo aus ein Premium-Exit erfolgt: Region, Stadt, Netzwerk, Gerät und wie lange die Adresse beibehalten wird. Die Listen für Region, Stadt und Netzwerk werden befüllt, wenn **exitCountries** genau ein Land angibt. Setze **exitClass** auf `premium`, da jede dieser Optionen den Request ausschließlich über Premium-Exits leitet. Die Proxy-ID in der Antwort behält den Standort bei. Daher reicht es aus, sie an Single oder Browser zu übergeben. Siehe [Exit location](https://foura.ai/docs/api/endpoints#exit-location).

### Toolbar zurücksetzen

Der **Reset**-Button in der Toolbar (neben **History** und **Saved**) setzt den Playground in den Ausgangszustand zurück. Da dies destruktiv ist, öffnet sich ein Bestätigungsdialog mit der genauen Liste dessen, was gelöscht wird: jeder Request-Tab, alle gespeicherten Cookies im Jar, alle übertragenen Proxys und die aktuelle Response. Gespeicherte Presets und der ausgewählte API-Key bleiben erhalten. Klicke auf **Reset everything**, um zu bestätigen; jede andere Aktion bricht den Vorgang ab.

## Senden und Abbrechen

Klicke auf **Send**, um den Request abzuschicken. Die rechte Spalte wechselt in einen Ladezustand mit einem Spinner und einem **Cancel**-Button, während der Aufruf läuft. Klicke auf Cancel (oder tippe auf mobilen Geräten erneut auf den Button), um abzubrechen. Ein abgebrochener Request stellt den Idle-Platzhalter mit "Request canceled." wieder her, anstatt einen Fehler anzuzeigen.

Die Response-Karte schaltet auf das Ergebnis um, sobald der Request abgeschlossen ist (oder fehlschlägt). Auf einem Smartphone oder in Fenstern, die so schmal sind, dass die Response unter dem Formular liegt, scrollt die Seite die Response-Karte ins Sichtfeld, wenn sie weit unten auf dem Bildschirm erscheint. Auto-Ausführungen können länger dauern als manuelle Engines, da die Ladder bei einem Cold Target mehrere Stufen durchlaufen kann.

## Response lesen

Die Response-Spalte spiegelt das Request-Layout mit eigenen Tabs wider:

| Tab | Was angezeigt wird |
|-----|-------------------|
| Body | Geparster Body. Wechselt je nach Rückgabe zwischen den Ansichten JSON, HTML und Text. |
| Headers | Response-Header, eine Zeile pro Header. |
| Cookies | Vom Ziel zurückgegebene Cookies, sowohl in geparster (nach Host gruppierter) als auch in roher Ansicht (Set-Cookie-Text). Die geparste Ansicht zeigt ein `HO`-Badge bei Host-only-Cookies; Domain-Cookies sind unmarkiert. |
| Raw | Der vollständige JSON-Envelope, den die API zurückgegeben hat. |

Die Response-Symbolleiste bietet **Kopieren** und **Herunterladen** für die gesamte Response sowie **In Response suchen** (Strg+K oder Cmd+K), um den geöffneten Tab zu durchsuchen, mit Enter und Umschalt+Enter zum Navigieren durch die Treffer. Body, Headers und Cookies haben zudem eigene Buttons zum Kopieren und Herunterladen für den jeweiligen Tab.

Eine Metaleiste über den Tabs zeigt den Upstream-HTTP-Status, die Gesamtzeit, die Proxy-ID, die den Aufruf verarbeitet hat, und (bei einem scoped Proxy-Aufruf) den zweistelligen `exit <CODE>`. Die Leiste zeigt außerdem die Response-Größe und, sofern von der API gemeldet, die verbrauchten Credits des Requests an. Bei Auto-Ausführungen stehen die Stufe und die Versuche im Satz unter der Leiste.

### Was der Aufruf benötigte

Ein Satz unter der Metaleiste beschreibt in Textform, wie die Seite übertragen wurde. Bei einem Auto-Lauf nennt er die Stufe (eine Session, die FourA bereits für den Host hatte, ein einfacher Request, ein rotierender Proxy, ein echter Browser oder zuerst ein Browser und dann ein günstiger Replay), ob eine Challenge gelöst wurde, wie viele Versuche nötig waren und was es gekostet hat. Wenn der Request `exitClass` gesetzt hat, gibt er auch an, ob ein Premium-Exit oder der Standard-Pool die Seite ausgeliefert hat.

Wenn ein Limit deines Plans den Aufruf verweigert hat, weist der Satz zuerst darauf hin: "Von deinem Plan gestoppt, nicht von der Website", gefolgt von der Angabe, welches Limit erreicht wurde (heutige Browser-Requests aufgebraucht, zu viele gleichzeitige Requests, Credits dieses Abrechnungszeitraums verbraucht usw.) und einem Link zu [Nutzung & Limits](https://foura.ai/docs/dashboard/quota). Die Zeile wird aus dem von der API zurückgegebenen Code `X-FourA-Limit` generiert. So erfährst du bei einer fehlschlagenden schwierigen Seite, ob die Website oder dein Plan den Abbruch verursacht hat.

### Werte zwischen Läufen übernehmen

Nach jedem Lauf, der wiederverwendbare Session-Daten geliefert hat, zeigt ein kleines Bedienelement namens **Übernehmen** in der Response-Symbolleiste die verfügbaren Werte an:

- **Auto**-Läufe mit `returnSession` bieten `userAgent` und `proxy` der Session. Die Cookies der Session erscheinen im Tab **Cookies** der Response und wandern in den Cookie-Jar, wenn **Response-Cookies speichern** aktiviert ist.
- **Browser**-Läufe bieten `userAgent` der Response sowie die Proxy-ID, falls eine verwendet wurde.
- **Proxy**-Läufe bieten die zurückgegebene Proxy-ID und das Browser-Profil, falls die Rotation eines gewählt hat, das du nicht angefordert hattest.

Klicke auf **Übernehmen** und wähle mit einem Klick aus, wo jeder Wert angewendet werden soll: `userAgent` wird zu einem `User-Agent`-Header in Single oder Proxy, und die Proxy-ID wird in das Feld `proxy` in Single oder Browser eingefügt. Felder, die einen übernommenen Wert erhalten, zeigen den roten Punkt für "geändert", damit du siehst, was angepasst wurde.

Ein übernommenes **browser profile** füllt die drei Auswahllisten für OS, Browser und Version aus und aktiviert `unblocker`, dieselbe Regel gilt auch bei manueller Auswahl eines Profils. Es wird erst angeboten, sobald der Profilkatalog geladen ist, da das Formular aus drei Auswahllisten und keinem ID-Feld besteht.

Das Profil ist der einzige Wert, der anzeigt, dass der *erfolgreiche* Request nicht dem von dir eingegebenen Request entsprach: Proxy meldet `profile` nur dann, wenn zu einer Browser-Familie gewechselt wurde, die du nicht angefordert hast. Führst du den Replay ohne dieses Profil aus, wiederholst du die fehlgeschlagene Version. Siehe [Warum für einen Proxy-Request keine Versuche mehr übrig waren](https://foura.ai/docs/troubleshooting/proxy-attempt-report).

### Auf Vollbild vergrößern

Das Vergrößern-Symbol in der Response-Symbolleiste hebt die Response-Karte aus dem geteilten Layout in ein Vollbild-Overlay. Nutze es für tiefe JSON-Bäume, lange Set-Cookie-Dumps oder breite HTML-Bodys, wenn die Spalte mit halber Breite zu eng wird. Die Seite selbst scrollt nicht mehr, solange das Overlay geöffnet ist. Klicke erneut auf das Symbol (oder drücke Escape), um die Ansicht zu minimieren.

## Der curl-Reproduzierer

Auf dem **Raw**-Tab des Requests zeigt ein curl-Block unter dem JSON das genaue Befehlszeilenäquivalent des von dir erstellten Requests mit einer Schaltfläche **Copy curl**. Kopiere ihn, um den Request im Terminal zu reproduzieren, ihn mit einem Teamkollegen zu teilen oder in einen Fehlerbericht einzufügen.

Bei offenlegbaren Schlüsseln fügt eine Schaltfläche **Reveal key** neben dem Snippet den echten Klartextschlüssel direkt in den curl-Befehl ein, sodass du ihn unverändert kopieren und ausführen kannst. Klicke erneut darauf, um ihn auszublenden. Legacy-Schlüssel (erstellt vor Einführung der Reveal-Funktion) behalten einen Platzhalter `PASTE_PLAINTEXT_FOR_<key-name>`. Generiere den Schlüssel auf der Seite **API Keys** neu, um ihn offenlegbar zu machen.

Die Offenlegung wird jedes Mal auf dem Server auditiert, und der Klartextschlüssel verbleibt nur für die aktuelle Seitensitzung im Speicher.

## Presets speichern

Wenn du dasselbe Ziel wiederholt konfigurierst, speichere es. Klicke in der Zeile der Request-Tabs auf **Save**, um die aktuelle Konfiguration als benanntes Preset zu speichern.

Öffne **Saved** in der Symbolleiste, um deine Presets anzuzeigen. Klicke auf **Load**, um das Formular auszufüllen, oder auf **Delete**, um ein Preset zu entfernen.

Ein Request, der aus dem DevTools-Tab der FourA-Chrome-Erweiterung geöffnet wird, lädt mit dem ausgewählten Schlüssel der Erweiterung, sofern sich dieser Schlüssel in deinem Konto befindet, und die Seite weist darauf hin. Andernfalls wirst du aufgefordert, einen Schlüssel auszuwählen. Ein wiederholter Request, der `unblocker` nicht setzt, wird standardmäßig aktiviert ausgeführt, genau wie bei der API.

| Preset field | What it stores |
|--------------|----------------|
| Name | Ein kurzes Label (bis zu 100 Zeichen) |
| Description | Optionale Notizen (bis zu 500 Zeichen) |
| Endpoint | Für welche Engine das Preset bestimmt ist (auto / single / proxy / browser) |
| Config | Die gesamte Request-Payload einschließlich UI-Felder, Header, Cookies und Body |

Presets sind an dein Benutzerkonto gebunden und werden nicht mit Teammitgliedern geteilt.

## Replay aus dem Verlauf

Jeder von dir ausgeführte Request wird protokolliert. Öffne **History** in der Symbolleiste, um deine letzten 20 Durchläufe zu sehen, sortiert nach den neuesten zuerst.

Jede Zeile zeigt Endpoint, Ziel-URL, Status und Zeit. Klicke in einer beliebigen Zeile auf **Replay**, um diesen Request wieder in das Formular zu laden, und dann auf **Send**, um ihn erneut auszuführen.

Der Verlauf ist automatisch auf deinen Account beschränkt: Du siehst nur deine eigenen Durchläufe.

## Aus Activity öffnen

Der Detaildialog im [Activity Log](https://foura.ai/docs/dashboard/activity-log) enthält einen Button namens **Open in Playground**. Klicke darauf, und der Playground lädt sowohl den archivierten Request als auch die archivierte Response. Das Formular wird mit der gespeicherten Payload ausgefüllt, und die Response-Karte zeigt, was die API zu diesem Zeitpunkt zurückgegeben hat, samt einem "archived"-Badge auf der Proxy-Metaleiste ("archived <time> [, truncated] [, via <proxy>]").

Von dort aus kannst du einen Parameter ändern und auf **Send** klicken, um einen neuen Request an die Live-API zu senden, oder einfach die archivierte Payload prüfen, ohne sie erneut auszuführen. Payloads werden 24 Stunden lang aufbewahrt, ältere Activity-Zeilen haben daher keine neu ladbare Response.

## Tipps

- Starte im Playground, bevor du Code für ein neues Ziel schreibst. Wenn Auto aktiviert ist, weißt du innerhalb von Sekunden, ob ein günstiger Fetch ausreicht oder ob die Website ein Browser-Solving erzwingt.
- Führe bei Zielen mit Ländersperre einen Proxy-Aufruf mit gesetztem `exitCountries` aus und übergib die zurückgegebene Proxy-ID an einen Browser-Aufruf, damit das JavaScript-Rendering über denselben Exit-Knoten erfolgt.
- Speichere ein Preset für jedes Ziel, das du regelmäßig scrapst. Das erneute Abspielen eines gespeicherten Presets erfordert nur einen Klick; den Request aus dem Gedächtnis nachzubauen, dauert länger.
- Nutze den Tab Cookies, um session-basiertes Scraping zu debuggen. Die Ansicht der Rohdaten von Set-Cookie zeigt genau, was das Ziel gesendet hat.
- Wenn ein Ziel dich abweist, probiere einen anderen Eintrag in der Profilauswahl von Browser aus, bevor du zu einer schwereren Engine greifst. Das Wechseln des übergebenen Browsers ist kostenlos; ein Browser-Rendering nicht.
- Playground-Requests werden über den von dir ausgewählten Key abgerechnet. Nutze einen separaten Key mit niedrigem Kontingent für spontane Tests, wenn du die produktive Nutzung sauber halten willst.

## Verwandte Themen

- [API Endpoints](https://foura.ai/docs/api/endpoints): Vollständige Parameter-Referenz für alle vier Engines, einschließlich `exitCountries` und der Browser-Profilfelder
- [Smart Fetch (Auto)](https://foura.ai/docs/guides/smart-fetch): Was Auto im Hintergrund tut
- [Choosing the Right Endpoint](https://foura.ai/docs/guides/choosing-task-type): Wann du Auto vs Single vs Proxy vs Browser wählst
- [API Keys](https://foura.ai/docs/dashboard/api-keys): Verwalte die Keys, mit denen du Playground-Requests authentifizierst
- [Activity Log](https://foura.ai/docs/dashboard/activity-log): Öffne einen früheren Request direkt im Playground
- [Dashboard Overview](https://foura.ai/docs/dashboard/overview): Alle Seitenleisten-Bereiche
