# Smart Fetch (Auto)

> URL: https://foura.ai/de/docs/guides/smart-fetch
> Updated: 2026-11-13
> Index: https://foura.ai/llms.txt

Du übergibst FourA eine URL und eine `validate`-Regel dafür, was die echte Seite enthalten soll. FourA erledigt den Rest: Es durchläuft eine kostenbewusste Leiter, stoppt auf der ersten Stufe, die eine von deinen Regeln akzeptierte Response liefert, und merkt sich pro Host, was funktioniert hat, damit der nächste Aufruf derselben Website günstig ist.

Diese Anleitung erklärt, was auto unter der Haube tut, wann du es verwenden solltest und wie du die Response liest. Die Parameter-Referenz findest du unter [API Endpoints](https://foura.ai/docs/api/endpoints#smart-fetch-auto).

## Das Konzept

Die meisten Scraping-Setups zwingen dich, die Engine vorab zu wählen. Single ist am schnellsten, Proxy ergänzt Rotation, Browser verarbeitet JavaScript. Wenn du falsch rätst, verschwendest du Credits oder wirst blockiert.

Auto dreht das um. Du definierst den Erfolg (`validate`), nicht die Methode. FourA klettert eine Leiter hoch, bis eine Stufe erfolgreich ist:

1. **Günstiger Probe-Request** (single, direkt aus FourAs eigenem Netzwerk)
2. **Browser**, direkt aus FourAs eigenem Netzwerk, mit JavaScript und einem Solver, falls die Website Challenges stellt
3. **Rotierter Proxy single**
4. **Browser über Proxy** für die schwierigsten Ziele

Auto stoppt, sobald eine Stufe eine Response liefert, die deine `validate`-Regel akzeptiert.

Eine Stufe liegt außerhalb dieser Reihenfolge. Wenn ein Exit die Website erreicht, die Website aber die von dir angeforderte Deep-URL verweigert, ruft auto die Startseite der Website über denselben Exit ab, behält die von der Startseite ausgegebenen Cookies und fordert deine URL mit diesen Cookies erneut an. Das ist die `warmup`-Stufe. Sie läuft nur bei einer URL, die tiefer als das Root-Verzeichnis der Website liegt, nur nachdem der direkte Versuch bereits fehlgeschlagen ist, und sie kann ein Ergebnis nur ergänzen, nie verschlechtern.

`forceProxy` ist standardmäßig `true`, sodass die Stufen 1 und 2 übersprungen werden und das Ziel FourAs eigene Adresse nie sieht. Die meisten Aufrufe enden dann auf Stufe 3 oder mit einer wiederverwendeten warmen Session. Setze `forceProxy: false`, wenn du weißt, dass ein Ziel eine saubere Adresse besser behandelt als eine rotierende, und die Stufen 1 und 2 werden wieder aktiviert.

## Was du sendest

Das Minimum ist eine URL plus ein `validate`-Substring. Auto erkennt gängige Challenge-Seiten von selbst, aber ohne `validate.data.accept` kann es eine echte Seite nicht von einer unbekannten Prüfseite oder einer Seite ohne deinen Inhalt unterscheiden und liefert möglicherweise beides als Erfolg zurück.

```bash
curl -X POST https://eu.api.foura.ai/api/auto/ \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/product/42",
    "validate": {"data": {"accept": ["Add to cart"]}}
  }'
```

Optionale Parameter (vollständige Details findest du in der [Endpoint-Referenz](https://foura.ai/docs/api/endpoints#smart-fetch-auto)):

- `returnSession` (Standard `true`): Gibt den erfolgreichen `{ proxy, cookies, userAgent }` zurück, damit du ihn erneut abspielen kannst.
- `forceProxy` (Standard `true`): Überspringt Direct-Egress-Stufen. Setze `false` nur, wenn du weißt, dass die Website mit einer sauberen IP besser funktioniert als mit rotierenden Exits.
- `timeout_ms` (Standard `120000`): Gesamtbudget für den gesamten Aufruf. Die Ladder teilt es auf die einzelnen Stufen auf.
- `ignoreProxies`: Proxy-IDs, die bei jedem Teilversuch vermieden werden sollen.
- `followRedirects` (Standard `5`): Maximale Weiterleitungen auf den günstigen Stufen.
- `headers`: Header, die an die Website gesendet werden, als `[name, value]`-Paare. Sie werden bei den Single- und Proxy-Requests gesendet, einschließlich der Suche nach einem funktionierenden Exit. Die Browser-Stufen senden sie nicht. Dein eigener `Cookie` erreicht die Website unverändert, und Cookies einer warmen Session werden daneben nur unter Namen ergänzt, die du nicht gesendet hast. Wenn eine warme Session einen `userAgent` enthält, ersetzt er deinen `User-Agent`. Bedingte Header wie `If-None-Match` und `If-Modified-Since` werden bei der Exit-Suche weggelassen, es sei denn, dein `validate.status.accept` listet `304` auf.
- `exitClass`: `premium` erlaubt Auto die Eskalation auf einen Premium-Exit, sobald der Standard-Pool die Seite nicht erreichen kann; `standard` verhindert jede Eskalation. Erfordert einen Plan mit Premium-Exits. Siehe [exitClass bei Smart Fetch](https://foura.ai/docs/api/endpoints#exitclass-on-smart-fetch).

## Was du zurückbekommst

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "headers": [{"content-type": "text/html"}],
  "meta": {
    "rung": "cache",
    "solved": false,
    "attempts": 1,
    "credits": 2,
    "attemptsByEngine": {"single": 1, "proxy": 0, "browser": 0},
    "browserRequests": 0
  },
  "session": {
    "proxy": "A1B2C3",
    "cookies": [{"name": "session", "value": "abc", "domain": "example.com"}],
    "userAgent": "Mozilla/5.0..."
  }
}
```

Drei Dinge zum Lesen:

- **`status` und `data`**: die Antwort des Ziels. `data` ist Text, egal welche Stufe die Seite ausgeliefert hat. Eine JSON-Seite kommt also als JSON-Text an und du parst sie selbst. `status` ist der HTTP-Status des Ziels, nicht der Transportstatus deines Aufrufs an FourA. Bei Single- und Proxy-Stufen ist `headers` ein Array pro Hop. Bei Browser-Stufen ist `headers` ein flaches Objekt.
- **`meta`**: der Trace dessen, was die Leiter getan hat, vorhanden bei jeder Antwort, sobald die Leiter gestartet wurde. `meta.rung` benennt den Schritt, der die Antwort geliefert hat, `meta.attempts` zählt die Versuche von Unteraufrufen, `meta.solved` zeigt an, ob eine Challenge-Seite gelöst wurde, und `meta.credits` sind die Gesamtkosten des Aufrufs (dieselbe Zahl wie im Header `X-FourA-Credits`). `meta.attemptsByEngine` und `meta.browserRequests` geben an, was der Aufruf verbraucht hat: siehe [Was ein Aufruf verbraucht hat](#what-a-call-spent). Wenn der Request einen `exitClass` angegeben hat, zeigt `meta.exitClass`, welche Exit-Klasse geliefert hat.
- **`session`**: das `{ proxy, cookies, userAgent }`-Tripel, das das Ziel geknackt hat. Nutze es zum Replay gegen denselben Host via `/api/single/` oder `/api/browser/`. Ein Feld kann fehlen: Eine Session, die durch einen einfachen Proxy-Fetch gewonnen wurde, enthält `proxy`, aber kein `userAgent`, und ihre `cookies`-Liste enthält nur Cookies, die die Check-Seite einer Website gesetzt hat, bevor die Seite ausgeliefert wurde; sie ist daher oft leer. Eine Antwort des günstigen direkten Probes enthält nur dann eine `session`, wenn eine solche Check-Seite Cookies gesetzt hat, und dann enthält sie nur `cookies`. Ein Status, den deine `validate.status.accept` auflistet und den ein Exit zurückgebracht hat (wie das `404` einer entfernten Seite), hat überhaupt keine `session`.

Auto antwortet mit HTTP 200, wann immer die Leiter lief, selbst wenn jede Stufe fehlschlug. Lies `status` und `error` im Body, um herauszufinden, was passiert ist, nicht den Transport-Statuscode. Ein Nicht-200-Code von `/api/auto/` bedeutet, dass der Aufruf die Leiter nie erreicht hat: 401 bei einem ungültigen Key, 400 bei einem Body, der kein gültiges JSON ist, einem Ziel in einem privaten Netzwerk, einem Ziel auf FourAs eigenem API-Host oder einer URL mit einem uncodierten Leerzeichen darin, 403 mit `X-FourA-Limit: plan_limit_premium` bei `exitClass: premium` auf einem Plan ohne Premium-Exits, sowie 502, 503 oder 504, wenn der Dienst den Aufruf nicht annehmen konnte oder ein Timeout auftrat. Auto belegt keinen Slot am Gateway, daher weisen die geteilten Limits der Plattform den Aufruf selbst nicht ab: Wenn eines einen Aufruf abweist, den die Leiter getätigt hat, lautet die Antwort HTTP 200 mit `status: 429` oder `503` und `retryAfter` im Body. Ein Feld, das die Validierung nicht besteht, kommt ebenfalls als HTTP 200 mit `status: 400` zurück. Ein innerhalb der Leiter erreichtes Plan-Limit kommt ebenfalls als HTTP 200 mit der Ablehnung im Body zurück (siehe [Wenn die Limits deines Plans die Leiter treffen](#when-your-plans-limits-meet-the-ladder)).

## Replay mit der Session

Nachdem Auto eine Session zurückgibt, kannst du für Folgeseiten auf demselben Host direkt in Single oder Browser einsteigen. Kein neuer Leiter-Durchlauf, kein neuer Probe.

```python
import requests

API = "https://eu.api.foura.ai"
KEY = "YOUR_API_KEY"
H = {"X-API-Key": KEY, "Content-Type": "application/json"}

# 1) First call: let auto figure it out.
r = requests.post(f"{API}/api/auto/", headers=H, json={
    "url": "https://example.com/product/42",
    "validate": {"data": {"accept": ["Add to cart"]}},
}).json()

session = r.get("session") or {}
proxy = session.get("proxy")
user_agent = session.get("userAgent")

# 2) Follow-up pages: replay through single with the same proxy, UA and cookies.
for sku in ("43", "44", "45"):
    body = {"method": "GET", "url": f"https://example.com/product/{sku}"}
    if proxy:
        body["proxy"] = proxy
    headers = []
    if user_agent:
        headers.append(["User-Agent", user_agent])
    if session.get("cookies"):
        headers.append(["Cookie", "; ".join(f"{c['name']}={c['value']}" for c in session["cookies"])])
    if headers:
        body["headers"] = headers
    r = requests.post(f"{API}/api/single/", headers=H, json=body).json()
    print(sku, r["status"])
```

Die Session ist nur so langlebig, wie das Ziel es zulässt. Manche Websites binden die Freigabe stundenlang an die Cookie Jar, andere rotieren alle paar Minuten. Wenn ein Replay wieder Challenges zurückgibt, rufe `/api/auto/` erneut auf, um sie zu aktualisieren.

## Wann du Auto verwenden solltest

| Auto verwenden | Single, Proxy oder Browser manuell verwenden |
|----------------|----------------------------------------------|
| Du sprichst eine neue Website an und weißt nicht, was sie benötigt | Du kennst bereits die Engine, die funktioniert |
| Du möchtest einen einzigen Call, der Proxy- und Browser-Fallback für dich übernimmt | Du möchtest die volle Kontrolle über Retries und Timeouts pro Call |
| Es ist in Ordnung für dich, beim ersten Call wenige Sekunden für das Probing zu investieren | Die Latenz des ersten Calls ist wichtiger als die Erkennung |
| Du möchtest eine erlernte Session, die du kostengünstig wiederholen kannst | Du optimierst eine enge Schleife auf einem bekanntermaßen funktionierenden Ziel |

Auto ist nicht immer die günstigste Wahl. Wenn du weißt, dass ein Ziel mit `single` + `unblocker` funktioniert, kostet der direkte Aufruf von Single 2 Credits bei vorhersehbarer Latenz. Auto auf demselben Ziel kostet das, was die Erkennungsleiter verbraucht, was mehr sein kann, wenn die Website eine Eskalation erfordert.

## Validate teilt Auto mit, was "Erfolg" bedeutet

Der wichtigste Parameter ist `validate`. Ohne ihn weist Auto nur die Challenge-Seiten ab, die es erkennt. Eine unbekannte Prüfseite oder eine leere Shell mit HTTP 200 wird sonst als Inhalt gewertet.

Verwende `validate.data.accept` mit einem Substring, den nur die echte Seite enthält:

```json
{
  "validate": {
    "data": {
      "accept": ["sku-42-add-to-cart", "Customer reviews"]
    }
  }
}
```

Akzeptiere bei JSON-APIs einen Feldnamen, den du erwartest:

```json
{
  "validate": {
    "data": { "accept": ["\"products\":["] },
    "status": { "accept": [200] }
  }
}
```

Für Websites, die berechtigterweise Nicht-200-Statuscodes zurückgeben (eine Ländersperre, die du ignorieren möchtest, oder `404` bzw. `410` einer entfernten Seite), erlaube diese über `validate.status.accept`:

```json
{
  "validate": {
    "status": { "accept": [200, 451] }
  }
}
```

Auto gibt einen Status zurück, den du in `validate.status.accept` angibst, sobald ein Exit ihn zurückbringt und er den Rest deiner Regel besteht. Vier Statuswerte sind die Ausnahme: `202`, `403`, `429` und `503`. Auto interpretiert diese so, dass die Website prüft, wer anfragt. Ein Exit, der einen dieser Statuswerte liefert, beendet die Suche daher nicht, und die Leiter steigt weiter auf.

Ohne `validate` fällt Auto für jede Seite, die es nicht als Challenge erkennt, auf "HTTP 200 = Erfolg" zurück. Es erfasst also keine unbekannte Prüfseite, die eine Website mit einem 200-Status ausliefert.

## `meta.rung` lesen, um zu verstehen, was passiert ist

`meta.rung` ist das nützlichste Debug-Signal. Werte:

- `probe` - über einen günstigen direkten Request gelöst. Der günstigste Pfad.
- `proxy` - erforderte Proxy-Rotation, um durchzukommen.
- `browser` - erforderte ein vollständiges Browser-Rendering, möglicherweise mit dem Lösen einer Challenge.
- `cache` - hat eine bestehende Session aus einem früheren Auto-Aufruf wiederverwendet. Günstigster Pfad bei wiederholten Aufrufen.
- `warmup` - die Website hat ihre Einstiegsseite ausgeliefert, aber die Deep-URL blockiert. Auto hat daher zuerst die Einstiegsseite abgerufen, die vergebenen Cookies behalten und die Anfrage damit wiederholt. Die auf dieser Stufe gespeicherte Session ist nicht an einen einzelnen Exit gebunden, sodass Folgeaufrufe auf den günstigen Stufen landen.
- `fail` - keine Stufe lieferte eine Response, die deine Regeln akzeptiert haben.

`meta.solved: true` bedeutet, dass während des Aufrufs eine Challenge-Seite aufgetreten ist und gelöst wurde. `meta.attempts` ist die Anzahl der Sub-Call-Versuche vor dem Erfolg. Details dazu findest du im Feld `defense`, das die Single- und Proxy-Stufen zurückgeben: siehe [Site checks](https://foura.ai/docs/api/site-checks).

Wenn eine Website immer wieder bei `browser` endet, obwohl du `probe` erwartet hast, prüfe, ob eine strengere (oder weniger strenge) `validate`-Regel einer günstigeren Stufe den Durchlauf erlauben würde. Beachte, dass `forceProxy` standardmäßig auf `true` steht, sodass der Direct-Egress-Test übersprungen wird, sofern du ihn nicht deaktivierst.

## Was ein Aufruf verbraucht hat

`meta.attemptsByEngine` zählt die Requests, die der Aufruf an jede Engine gesendet hat, dieselben Requests, die der Bereich "Auto attempts" in deiner [Overview](https://foura.ai/docs/dashboard/overview) anzeigt. `meta.browserRequests` zählt diejenigen, die ein Kontingent deines täglichen Browser-Guthabens verbraucht haben.

```json
"meta": {
  "rung": "browser",
  "solved": true,
  "attempts": 7,
  "credits": 47,
  "attemptsByEngine": {"single": 1, "proxy": 4, "browser": 3},
  "browserRequests": 2
}
```

| Feld | Typ | Beschreibung |
|-------|------|-------------|
| `meta.attemptsByEngine` | object | Requests, die an `single`, `proxy` und `browser` gesendet wurden. Ein Browser-Request, den dein Plan abgelehnt hat, zählt hierzu, da er gesendet wurde. |
| `meta.browserRequests` | number | Browser-Requests, die einen Slot deines Tageskontingents belegt haben. Ein von deinem Plan abgelehnter Browser-Request belegt keinen Slot. |

`meta.attempts` zählt die Stufen der Kaskade, weshalb der Wert nicht immer der Summe von `meta.attemptsByEngine` entspricht. Ein Schritt kann einen Single-Request und anschließend einen Proxy-Request senden, und ein Schritt, dessen Browser für den Tag bereits geschlossen ist, sendet nichts.

Dein aktueller Zählerstand für den Tag wird in den Headern `X-FourA-Browser-Used-Today` und `X-FourA-Browser-Limit-Per-Day` übertragen: siehe [Response Headers](https://foura.ai/docs/api/response-headers).

## Fehler und Randfälle

Wenn auto fehlschlägt, enthält die Response `status` (üblicherweise der Status der zuletzt fehlgeschlagenen Stufe) und einen `error`-String:

```json
{
  "status": 502,
  "error": "could not find a working exit for the target",
  "attempts": 7,
  "attemptReport": {
    "total": 7,
    "noResponse": 5,
    "defense": 2,
    "contentRejected": 0,
    "statusRejected": 0,
    "other": 0,
    "vendors": ["datadome"],
    "summary": "7 attempt(s): 5 got no answer from the site; 2 refused by the site (datadome)"
  },
  "meta": {
    "rung": "fail",
    "solved": false,
    "attempts": 7,
    "credits": 47,
    "attemptsByEngine": {"single": 0, "proxy": 4, "browser": 3},
    "browserRequests": 3
  }
}
```

`status` ist die Antwort der Website beim letzten Versuch, den Auto abgelehnt hat, wie etwa ein `403`. Wenn überhaupt kein Versuch eine Antwort von der Website erhalten hat, ist es meist `502` oder `504`, und `error` gibt an, ob kein funktionierender Exit gefunden wurde oder das `timeout_ms`-Budget aufgebraucht war. `status: 0` bedeutet lediglich, dass der Hostname des Ziels nicht aufgelöst werden konnte. Diese Antwort enthält kein `meta`, da die Ladder nie gestartet wurde.

Auto stoppt auch vorzeitig, wenn sein Browser wiederholt auf eine Prüfung stößt, die er nicht abschließen kann. Wenn zwei Exits den Browser auf diese Weise abweisen und die Suche nach einem Exit, dessen einfacher Abruf deine `validate`-Regel erfüllt, erfolglos bleibt, oder nach drei solchen Exits, endet der Aufruf. `status` enthält die letzte Antwort der Website und `error` beginnt mit `the browser was refused by`, gefolgt vom Namen des Prüfsystems.

Auto stoppt auch, wenn die Website selbst meldet, dass die Seite nicht existiert. Wenn zwei Exits denselben `404` oder `410` zurückgeben und deine Regeln dies nicht akzeptieren, endet der Aufruf mit diesem `status`, und `error` beginnt mit `the site answered`. Wenn eine entfernte Seite für dich eine gültige Antwort ist, gib `404` oder `410` in `validate.status.accept` an: Auto liefert sie dann sofort als erfolgreich aus, sobald ein Exit sie zurückgibt.

Wenn vier aufeinanderfolgende Auto-Aufrufe mit deinem API-Key ohne die Seite enden, weil die Website die Anfragen kontinuierlich abgewiesen hat, pausiert Auto weitere Versuche für diese Website über deinen Key für 120 Sekunden. Ein Aufruf in dieser Zeit antwortet sofort mit `status: 503`, `error: "target temporarily unservable, retry later"` sowie `retryAfter` in Sekunden und ist kostenlos. Dies wird pro API-Key gezählt: Andere Keys, die dieselbe Website aufrufen, sind nicht betroffen, und jeder erfolgreiche Aufruf der Seite setzt den Zähler zurück. Ein Aufruf mit `exitClass: premium` wird dadurch nicht blockiert.

Prüfe `attemptReport`, `meta.attemptsByEngine` und `meta.credits`, um zu sehen, wie das Budget verbraucht wurde. Wenn `meta.attempts` hoch ist und `meta.rung` nach der Browser-Stufe `fail` lautet, benötigt das Ziel möglicherweise einen längeren `timeout_ms`, eine strengere `validate`-Regel oder ist über rotierende Proxys derzeit schlicht nicht erreichbar.

### Warum ein Auto-Aufruf fehlgeschlagen ist

Jede fehlgeschlagene Antwort einer ausgeführten Ladder enthält ein `attemptReport`. Es zählt die Engine-Requests, die ohne die Seite zurückkamen, jeweils einmalig unter der angetroffenen Ursache.

| Feld | Typ | Beschreibung |
|-------|------|-------------|
| `total` | integer | Requests, die ohne die Seite zurückkamen. Höchstens die Summe von `meta.attemptsByEngine`, da ein von deinem Plan abgelehnter Browser-Request das Ziel nie versucht hat. |
| `noResponse` | integer | Keine Antwort von der Website erhalten |
| `defense` | integer | Die Website hat den Request abgelehnt: Ein Bot-Check wurde erkannt, die Seite war eine Challenge oder die Website antwortete mit 401, 403, 429 oder 503 |
| `contentRejected` | integer | Die Seite wurde abgerufen und nur deine `validate`-Regel hat sie abgelehnt |
| `statusRejected` | integer | Die Website antwortete mit einem Status, den dein Request nicht akzeptiert, wie etwa 404 für eine entfernte Seite |
| `other` | integer | Aus einem anderen Grund fehlgeschlagen, z. B. durch einen Serverfehler |
| `vendors` | string[] | Bot-Check-Anbieter, die bei den aufgetretenen Ablehnungen des Calls erkannt wurden |
| `summary` | string | Ein aus den Zählern erstellter Satz, der sicher geloggt werden kann. Er nennt den HTTP-Status, mit dem die Website geantwortet hat, falls kein Anbieter erkannt wurde, und gibt an, wenn dein tägliches Browser-Kontingent aufgebraucht war, sodass kein Browser geöffnet werden konnte. |

Die Felder entsprechen dem Report bei einem fehlgeschlagenen [Proxy-Call](https://foura.ai/docs/troubleshooting/proxy-attempt-report), ohne `profilesTried`. Zwei Dinge unterscheiden sich. Proxy zählt jeden versuchten Exit bis zu dem von dir festgelegten `maxTries`, und Auto zählt seine eigenen Requests. Auto liest auch die Seite und ihren Status, sodass eine Ablehnung auch dann unter `defense` zählt, wenn kein Anbieter erkannt wurde. Einen Zählerstand unter `contentRejected` kannst du selbst beheben: Die Seite kam zurück und deine Regel passte nicht darauf.

### Wenn die Limits deines Plans auf die Ladder treffen

Die Sub-Calls von Auto sind reguläre Single-, Proxy- und Browser-Requests unter deinem Key, daher gelten deine [Plan-Limits](https://foura.ai/docs/api/rate-limits) für sie. Die Ladder liest den `X-FourA-Limit`-Code bei einer Ablehnung und behandelt die beiden Arten unterschiedlich.

**Eine geschlossene Sprosse lässt den Rest der Ladder nutzbar.** `plan_limit_browser_daily` (deine Browser-Requests für den Tag sind aufgebraucht) und `plan_limit_concurrency` (dieser Endpoint führt bereits so viele deiner Requests aus, wie der Plan erlaubt) schließen eine Sprosse. Auto nutzt die anderen Sprossen weiter, sodass du weiterhin eine Seite erhältst, sobald ein rotierender Exit oder eine warme Session den Inhalt liefert. Die versuchten Exits werden nicht für eine Ablehnung verantwortlich gemacht, die von deinem eigenen Plan stammt. Es wird nichts gesperrt und keine Session verworfen.

**Ein erschöpfter Account stoppt die Ladder.** `plan_limit_credits`, `plan_limit_bandwidth`, `plan_limit_rate`, `plan_limit_feature` und `plan_limit_premium` können durch keine andere Sprosse gelöst werden, daher kehrt Auto sofort zurück, anstatt weitere Credits dafür aufzuwenden. Die Ablehnung wird im Body mit dem Status des Sub-Calls und demselben `reason`-Feld zurückgegeben, das die direkten Endpoints verwenden:

```json
{
  "status": 429,
  "error": "Credit limit reached: 300,000 of 300,000 credits used this billing period. Upgrade your plan or wait for the reset.",
  "reason": "plan_limit_credits",
  "documentation": "https://foura.ai/prices",
  "used": 300000,
  "hard_stop": 300000,
  "retry_after_seconds": 86400,
  "resets_at": "2026-10-01T00:00:00.000Z",
  "meta": { "rung": "fail", "solved": false, "attempts": 1, "credits": 0 }
}
```

Der vollständige Ablehnungs-Body des Sub-Calls wird durchgereicht, plus `status`, `attemptReport` und `meta`. Lies `status` aus dem Body und nicht aus dem Transport-Status: auto antwortet hier weiterhin mit HTTP 200, da die Eskalationsleiter durchlaufen wurde. Eine `plan_limit_feature`- oder `plan_limit_premium`-Ablehnung wird auf dieselbe Weise mit `status: 403` übermittelt. Ein abgelehnter Sub-Call verbraucht kein Guthaben, daher zählt `meta.credits` nur die Stufen, die das Ziel tatsächlich erreicht haben.

Ein auto-Aufruf kann mehrere Slots belegen, während seine Eskalationsleiter aufsteigt. Daher erreicht ein paralleler Batch von auto-Aufrufen ein Concurrency-Limit mit weniger Calls als erwartet. [Run Requests in Parallel](https://foura.ai/docs/how-to/run-requests-in-parallel) behandelt die Dimensionierung des Batches.

## Was Auto nicht tut

- Es ändert keine rechtlichen Beschränkungen. Wenn eine Website jeden von FourA erreichbaren Exit ablehnt, gibt auto diese Ablehnung zurück.
- Es cacht keine Inhalte. Jeder Aufruf erreicht weiterhin das Ziel. Die "warm session" betrifft den Proxy und die Cookies, nicht die Response.
- Es ist eine einzelne Zeile im [Activity Log](https://foura.ai/docs/dashboard/activity-log) unter der Request-ID, die du erhalten hast, mit der Summe der Credits seiner Sub-Calls. Wenn du sie öffnest, sind die Single-, Proxy- und Browser-Sub-Calls, die auto für dich ausgeführt hat, als Versuche aufgeführt, jeder mit seinem eigenen Ergebnis. Sie zählen gegen deine Limits für Single, Proxy und Browser, aber nie gegen deine Request-Anzahl oder deine Erfolgsrate.

## Verwandte Themen

- [API Endpoints](https://foura.ai/docs/api/endpoints#smart-fetch-auto): Vollständige Parameter-Referenz
- [Choosing the Right Endpoint](https://foura.ai/docs/guides/choosing-task-type): Wann auto statt single, proxy oder browser gewählt werden sollte
- [Request Outcomes](https://foura.ai/docs/api/outcomes): Welche Ergebnisse abrechenbar sind
- [Protected sites](https://foura.ai/docs/guides/protected-sites): Was FourA auf Websites tut, die Anfragen prüfen
- [Site checks](https://foura.ai/docs/api/site-checks): Das `defense`-Feld hinter `meta.solved`
- [MCP Recipes](https://foura.ai/docs/mcp/recipes): Dieselben Muster als MCP-Tool-Calls
- [Rate Limits](https://foura.ai/docs/api/rate-limits): Die Tarif-Limits, an denen die Sub-Calls von auto gemessen werden
