> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Verarbeitung von documents mit separaten API-Aufrufen

> Verarbeiten Sie documents in ABBYY Vantage mit separaten API-Aufrufen: Erstellen Sie einen leeren Vorgang, fügen Sie Dateien hinzu, starten Sie die Verarbeitung, überwachen Sie den Status und laden Sie die Ergebnisse herunter.

export const VantageRegion = ({children}) => {
  const STORAGE_KEY = "abbyy.vantage.region";
  const REGIONS = [{
    code: "eu",
    label: "Europe"
  }, {
    code: "us",
    label: "North America"
  }, {
    code: "au",
    label: "Australia / Asia-Pacific"
  }];
  const [region, setRegion] = useState("eu");
  const [open, setOpen] = useState(false);
  const containerRef = useRef(null);
  const dropdownRef = useRef(null);
  function safeGetSavedRegion() {
    try {
      const saved = typeof window !== "undefined" ? window.localStorage.getItem(STORAGE_KEY) : null;
      const valid = new Set(REGIONS.map(r => r.code));
      return saved && valid.has(saved) ? saved : "eu";
    } catch {
      return "eu";
    }
  }
  function safeSetSavedRegion(code) {
    try {
      if (typeof window !== "undefined") {
        window.localStorage.setItem(STORAGE_KEY, code);
      }
    } catch {}
  }
  function dispatchRegionChanged(code) {
    try {
      if (typeof window !== "undefined") {
        window.dispatchEvent(new CustomEvent("abbyy:region-changed", {
          detail: {
            code
          }
        }));
      }
    } catch {}
  }
  function replaceRegionInString(text, currentRegion) {
    if (typeof text !== "string") return text;
    const hostRegex = /https:\/\/vantage-(eu|us|au)\.abbyy\.com/gi;
    const tokenRegex = /https:\/\/vantage-\[region\]\.abbyy\.com/gi;
    const bareHostRegex = /vantage-(eu|us|au)\.abbyy\.com/gi;
    const bareTokenRegex = /vantage-\[region\]\.abbyy\.com/gi;
    return text.replace(hostRegex, `https://vantage-${currentRegion}.abbyy.com`).replace(tokenRegex, `https://vantage-${currentRegion}.abbyy.com`).replace(bareHostRegex, `vantage-${currentRegion}.abbyy.com`).replace(bareTokenRegex, `vantage-${currentRegion}.abbyy.com`);
  }
  useEffect(() => {
    setRegion(safeGetSavedRegion());
  }, []);
  useEffect(() => {
    const root = containerRef.current;
    if (!root) return;
    const anchors = root.querySelectorAll("a[href]");
    anchors.forEach(a => {
      const href = a.getAttribute("href");
      if (href) {
        const next = replaceRegionInString(href, region);
        if (next !== href) {
          a.setAttribute("href", next);
        }
      }
    });
    const walker = typeof document !== "undefined" ? document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null) : null;
    if (walker) {
      const toUpdate = [];
      let node = walker.nextNode();
      while (node) {
        const updated = replaceRegionInString(node.nodeValue, region);
        if (updated !== node.nodeValue) {
          toUpdate.push([node, updated]);
        }
        node = walker.nextNode();
      }
      toUpdate.forEach(([textNode, value]) => {
        textNode.nodeValue = value;
      });
    }
  }, [region, children]);
  useEffect(() => {
    const root = containerRef.current;
    if (!root) return;
    const anchors = root.querySelectorAll("a[href]");
    anchors.forEach(a => {
      a.style.fontWeight = "600";
      a.style.textDecoration = "underline";
      a.style.textUnderlineOffset = "2px";
    });
  }, [region, children]);
  useEffect(() => {
    const onRegionChanged = evt => {
      const code = evt && evt.detail && evt.detail.code;
      if (!code || code === region) return;
      setRegion(code);
    };
    if (typeof window !== "undefined") {
      window.addEventListener("abbyy:region-changed", onRegionChanged);
    }
    return () => {
      if (typeof window !== "undefined") {
        window.removeEventListener("abbyy:region-changed", onRegionChanged);
      }
    };
  }, [region]);
  useEffect(() => {
    const onClickAway = e => {
      if (!dropdownRef.current) return;
      if (!dropdownRef.current.contains(e.target)) {
        setOpen(false);
      }
    };
    document.addEventListener("click", onClickAway, true);
    return () => document.removeEventListener("click", onClickAway, true);
  }, []);
  const onSelect = code => {
    setRegion(code);
    safeSetSavedRegion(code);
    dispatchRegionChanged(code);
    setOpen(false);
  };
  const current = REGIONS.find(r => r.code === region) || REGIONS[0];
  return <div className="not-prose">
      <div className="mb-4 inline-flex items-center gap-2" ref={dropdownRef}>
        <span className="text-sm text-zinc-950/80 dark:text-white/80">Tenant Region:</span>
        <div className="relative">
          <button type="button" aria-haspopup="listbox" aria-expanded={open ? "true" : "false"} onClick={() => setOpen(v => !v)} className="h-8 px-3 rounded-md bg-zinc-900/5 dark:bg-white/5 border border-zinc-950/20 dark:border-white/20 text-sm inline-flex items-center gap-2">
            <span className="text-zinc-950 dark:text-white">{current.label}</span>
            <svg width="8" height="24" viewBox="0 -9 3 24" className="transition-transform text-gray-400 overflow-visible dark:text-gray-600 ml-auto" style={{
    transform: open ? "rotate(270deg)" : "rotate(90deg)"
  }}>
              <path d="M0 0L3 3L0 6" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round"></path>
            </svg>
          </button>
          {open ? <div role="listbox" className="absolute z-50 left-full top-0 ml-2 w-56 rounded-xl border border-zinc-950/20 dark:border-white/20 bg-white dark:bg-zinc-900 shadow-lg p-2">
              {REGIONS.map(r => {
    const selected = r.code === region;
    return <button key={r.code} type="button" role="option" aria-selected={selected ? "true" : "false"} onClick={() => onSelect(r.code)} className={"w-full flex items-center justify-between px-3 py-2 rounded-lg text-sm hover:bg-zinc-950/5 dark:hover:bg-white/10 text-zinc-950 dark:text-white" + (selected ? " font-medium" : "")}>
                    <span style={selected ? {
      color: "#ff2038"
    } : undefined}>{r.label}</span>
                    <span className={selected ? "ml-3" : "ml-3 invisible"} style={selected ? {
      color: "#ff2038"
    } : undefined}>✓</span>
                  </button>;
  })}
            </div> : null}
        </div>
      </div>
      <div ref={containerRef} className="prose dark:prose-invert max-w-none">{children}</div>
    </div>;
};

Ein typisches Szenario für die Verarbeitung von documents mit separaten API-Aufrufen (zum Erstellen eines Vorgangs, Hochladen einer Datei und Starten eines Vorgangs) besteht aus den folgenden Schritten:

1. [Abrufen einer Liste aller verfügbaren Skills](#receiving-a-list-of-all-available-skills)
2. [Erstellen eines leeren Vorgangs](#creating-an-empty-transaction)
3. [Hinzufügen eines Satzes von Dateien, die im Vorgang verarbeitet werden sollen](#adding-a-set-of-files-to-be-processed-in-the-transaction)
4. [Starten des Vorgangs](#starting-the-transaction)
5. [Überwachen des Vorgangsstatus](#monitoring-the-transaction-status)
6. [Herunterladen von Quelldateien und Ergebnisdateien](#downloading-source-files-and-result-files)

Jede Anfrage an den Server muss Authentifizierungsinformationen (wie ein Access Token) enthalten. Weitere Informationen finden Sie unter [Authentifizierung](/de/vantage/developer/authentication/authentication).

<div id="receiving-a-list-of-all-available-skills">
  ### Eine Liste aller verfügbaren Skills abrufen
</div>

Senden Sie dazu eine `GET`-Anfrage an die Ressource `skills`:

<VantageRegion>
  ```
  GET https://vantage-us.abbyy.com/api/publicapi/v1/skills
  ```
</VantageRegion>

Führen Sie den folgenden Befehl aus:

<VantageRegion>
  ```bash theme={null}
  curl -X GET "https://vantage-us.abbyy.com/api/publicapi/v1/skills" \
  -H "Authorization: Bearer token"
  ```
</VantageRegion>

Die Antwort enthält eine JSON-Datei, die in etwa wie folgt aussieht:

```
[
   {
      "id": "Receipt",
      "name": "Receipt",
      "type": "Document"
   },
   {
      "id": "c4b26798-07cb-11eb-adc1-0242ac120002",
      "name": "NewClassifier",
      "type": "Classification"
   },
   {
      "id": "c4b26798-07cb-11eb-adc1-0242ac120002",
      "name": "Invoice",
      "type": "Document"
   }
]
```

Definieren Sie die Skill-ID, die Sie verwenden möchten. Detaillierte Beschreibungen der Skills finden Sie bei den integrierten Skills.

<div id="creating-an-empty-transaction">
  ### Einen leeren Vorgang erstellen
</div>

Senden Sie dazu die folgende `POST`-Anfrage an die Ressource `transactions`:

<VantageRegion>
  ```
  POST https://vantage-us.abbyy.com/api/publicapi/v1/transactions
  ```
</VantageRegion>

Führen Sie den folgenden Befehl aus:

<VantageRegion>
  ```bash theme={null}
  curl -X POST "https://vantage-us.abbyy.com/api/publicapi/v1/transactions" \
  -H "accept: */*" \
  -H "Authorization: Bearer token" \
  -H "Content-Type: application/json" \
  -d "{\"skillId\":\"123\"}"
  ```
</VantageRegion>

Nachdem ein leerer Vorgang erfolgreich erstellt wurde, erhalten Sie eine Antwort mit der Vorgangs-ID:

```
{
   "transactionId": "3fa85f64-5717-4562-b3fc-2c963f66afa6"
}
```

<div id="adding-a-set-of-files-to-be-processed-in-the-transaction">
  ### Hinzufügen eines Dateisatzes, der im Vorgang verarbeitet werden soll
</div>

<Info>
  Die maximale Anzahl von Dateien in einem Vorgang beträgt 1000.
</Info>

Ein Dateisatz kann auf zwei Arten hinzugefügt werden:

* [Direkt zum Vorgang](#adding-files-directly-to-the-transaction)
* [Zu einem Document und anschließend dieses Document zum Vorgang hinzufügen](#adding-files-to-a-document)

<div id="adding-files-directly-to-the-transaction">
  #### Dateien direkt zum Vorgang hinzufügen
</div>

Senden Sie dazu eine `POST`-Anfrage an die Ressource `transactions/<transaction-id>/files`:

<VantageRegion>
  ```
  POST https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/files
  ```
</VantageRegion>

<VantageRegion>
  Senden Sie im Body der Anforderung die zu verarbeitende Datei. Details zu den verfügbaren Parametern zur Anpassung von Dateien finden Sie in der [API Reference](https://vantage-us.abbyy.com/api/swagger).
</VantageRegion>

Führen Sie den folgenden Befehl aus:

<VantageRegion>
  ```bash theme={null}
  curl -X POST "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/files/" \
  -H "Authorization: Bearer token" \
  -F "Files=@Invoice07.jpg; type=image/jpeg"
  ```
</VantageRegion>

Als Ergebnis erhalten Sie eine Antwort mit einer Liste der hinzugefügten Dateien und deren Identifikatoren. Sie können beliebig viele Dateien hinzufügen, indem Sie diesen Aufruf mehrfach wiederholen.

Zusätzliche Optionen zum Hochladen von Dateien:

* [Hinzugefügte Bilder bearbeiten](/de/vantage/developer/processing-documents/editing-added-images)
* [Dateien und documents anordnen](/de/vantage/developer/processing-documents/ordering-files-and-docs)

<div id="adding-files-to-a-document">
  #### Dateien zu einem Document hinzufügen
</div>

Erstellen Sie zunächst ein Document, indem Sie eine `POST`-Anfrage an die Ressource `transactions/<transaction-id>/documents` senden:

<VantageRegion>
  ```
  POST https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents
  ```
</VantageRegion>

<VantageRegion>
  ```bash theme={null}
  curl -X POST "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents/" \
  -H "Authorization: Bearer token" \
  -H "Content-Type: application/json-patch+json"
  ```
</VantageRegion>

Als Ergebnis erhalten Sie eine Antwort mit der Document-ID.

Fügen Sie anschließend dem Document Dateien hinzu, indem Sie eine `POST`-Anfrage an die Ressource `transactions/<transaction-id>/documents/<document-id>/sourceFiles` senden:

<VantageRegion>
  ```
  POST https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents/document-id/sourceFiles
  ```
</VantageRegion>

<VantageRegion>
  ```bash theme={null}
  curl -X POST "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents/document-id/sourceFiles/" \
  -H "Authorization: Bearer token" \
  -F "Files=@Invoice07.jpg; type=image/jpeg"
  ```
</VantageRegion>

<div id="starting-the-transaction">
  ### Starten des Vorgangs
</div>

Um den Vorgang mit dem angegebenen Skill und den Dateien zu starten, senden Sie die folgende `POST`-Anfrage an die Ressource `transactions/<transaction-id>/start`:

<VantageRegion>
  ```
  POST https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/start
  ```
</VantageRegion>

<VantageRegion>
  ```bash theme={null}
  curl -X POST "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/start" \
  -H "accept: */*" \
  -H "Authorization: Bearer token" \
  -d ""
  ```
</VantageRegion>

<div id="monitoring-the-transaction-status">
  ### Überwachung des Vorgangsstatus
</div>

Um den Vorgangsstatus zu überwachen, verwenden Sie eine Schleife mit kurzem Timeout (prüfen Sie den Status nicht häufiger als einmal pro Sekunde) und senden Sie eine `GET`-Anfrage an die Ressource `transactions/<transaction_id>` mit der Vorgangs-ID in der Anforderungs-URI:

<VantageRegion>
  ```
  GET https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id
  ```
</VantageRegion>

<VantageRegion>
  ```bash theme={null}
  curl -X GET "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id" \
  -H "Authorization: Bearer token"
  ```
</VantageRegion>

Die Antwort sieht in etwa wie folgt aus:

```
{
   "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
   "status": "Processing", 
   "manualReviewLink": "https://vantage-us.abbyy.com/api/publicapi/v1/verify?documentIds=9838448d-72ae-4e9a-b071-2bb16f732e46",
   "sourceFiles": [
      {
         "id": "7b2eed6f-3fdd-43b9-a178-7211d0a8d5bb",
         "name": "Invoice07.JPG"
      }
   ]
}
```

In der Antwort:

* Wenn der Wert des Schlüssels **status** auf Folgendes gesetzt ist:
  * **New** — der Vorgang wurde erstellt, wird aber derzeit nicht verarbeitet.
  * **Processing** — der Vorgang wurde gestartet, aber die Ergebnisse sind noch nicht verfügbar.
  * **Processed** — der Vorgang wurde erfolgreich abgeschlossen, und Sie können die Ergebnisse herunterladen.
  * **Failed** — der Vorgang ist fehlgeschlagen.
  * **Canceled** — der Vorgang wurde abgebrochen.
* Der Schlüssel **manualReviewLink** enthält einen Link zur Weboberfläche des Manual Review-Clients und ein Vantage-Zugriffstoken, falls eine Manuelle Überprüfung erforderlich ist. Dieser Link und das Token können verwendet werden, um die Ergebnisse der Klassifizierung und Feldextraktion für einen bestimmten Vorgang zu überprüfen und zu korrigieren. Bis die Überprüfung abgeschlossen ist, ist der Wert des Schlüssels **status** auf **Processing** gesetzt. Der bereitgestellte Link ist 168 Stunden lang gültig. Danach sollte mit derselben Methode ein neuer Link erstellt und für einen weiteren Zeitraum von 168 Stunden abgerufen werden. Weitere Informationen finden Sie unter [Integrating manual review](/de/vantage/developer/integrating-manual-review).

<Info>
  Benutzer, die über diesen Link autorisiert sind, können keine anderen Documents oder Vorgänge anzeigen oder ändern.
</Info>

Bei einem Document-Skill sieht die Antwort nun etwa wie folgt aus:

```
{
   "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
   "status": "Processed",
   "documents": [
      {
         "id": "9838448d-72ae-4e9a-b071-2bb16f732e46",
         "resultFiles": [
            {
               "fileId": "3a3e6245-48e1-489a-9fef-a10b5ba28515",
               "type": "Json"
            }
         ],
         "businessRulesErrors": []
      }
   ],
   "sourceFiles": [
      {
         "id": "7b2eed6f-3fdd-43b9-a178-7211d0a8d5bb",
         "name": "Invoice07.jpg"
      }
   ]
}
```

Im Array **documents** hat jedes Dokument ein Array **resultFiles**. Verwenden Sie dieses Array, um die **fileId**-Werte abzurufen. Das Format der Ausgabedateien wird durch den Skill definiert, den Sie verwenden. Derzeit geben alle Skills die extrahierten Felder im [JSON-Format](/de/vantage/developer/output/json/json-output) zurück.

Bei einem Klassifizierungs‑Skill sieht die Antwort nach der Verarbeitung der Documents in etwa wie folgt aus:

```
{
   "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
   "status": "Processed",
   "documents": [
      {
         "id": "9838448d-72ae-4e9a-b071-2bb16f732e46",
         "classification": {
            "isResultClassConfident": true,
            "resultClass": "Invoice",
            "classConfidences": [
               {
                  "class": "Invoice",
                  "confidence": 89
               },
               {
                  "class": "PurchaseOrder",
                  "confidence": 32
               }
            ]
         }
      }
   ],
   "sourceFiles": [
      {
         "id": "7b2eed6f-3fdd-43b9-a178-7211d0a8d5bb",
         "name": "Invoice07.jpg"
      }
   ]
}
```

Entnehmen Sie die Klasse des Dokuments dem Schlüssel **resultClass** und prüfen Sie den Konfidenzwert jeder wahrscheinlichen Klasse in den Schlüsseln **confidence**.

Bei einem Process-Skill kann die Antwort je nach den im Process-Skill verfügbaren Verarbeitungsstufen alle oder nur einen Teil der Informationen enthalten, die für Dokument- und Klassifizierungs-Skills zurückgegeben werden.

<div id="downloading-source-files-and-result-files">
  ### Quelldateien und Ergebnisdateien herunterladen
</div>

Nachdem die Verarbeitung abgeschlossen ist, können Sie zwei Arten von Dateien herunterladen:

* **Quelldateien** — die ursprünglich hochgeladenen Dateien, die in ihrem ursprünglichen Binärformat zurückgegeben werden.
* **Ergebnisdateien** — die Verarbeitungsausgabe: die extrahierten Daten, standardmäßig im [JSON-Format](/de/vantage/developer/output/json/json-output) (das Ausgabeformat wird durch die Skill festgelegt).

<Info>
  Quelldateien und Ergebnisdateien verwenden unterschiedliche Endpoints und unterschiedliche Dateibezeichner:

  * **Quelldatei** — `GET transactions/<transaction-id>/documents/<document-id>/sourceFiles/<file-id>/download`. Die Datei-ID stammt aus der Antwort von `GET transactions/<transaction-id>/documents` (`sourceFiles[].id`).
  * **Ergebnisdatei** — `GET transactions/<transaction-id>/files/<file-id>/download`. Die Datei-ID stammt aus dem Array `resultFiles` in der Antwort zum [Vorgangsstatus](#monitoring-the-transaction-status) (`documents[].resultFiles[].fileId`).
</Info>

Um eine Liste von documents mit ihren Bezeichnern abzurufen, senden Sie eine `GET`-Anfrage an die Ressource `transactions/<transaction-id>/documents` und geben Sie die Vorgangs-ID an:

<VantageRegion>
  ```
  GET https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents
  ```
</VantageRegion>

<VantageRegion>
  ```bash theme={null}
  curl -X GET "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents" \
  -H "Authorization: Bearer token"
  ```
</VantageRegion>

Als Ergebnis erhalten Sie eine Liste aller documents, die innerhalb dieses Vorgangs erstellt wurden. Die Antwort enthält außerdem die Kennungen dieser documents, die benötigt werden können, um detaillierte Informationen zu bestimmten Dokumenten anzufordern.

<div id="source-files">
  #### Quelldateien
</div>

Um eine benötigte Quelldatei herunterzuladen, senden Sie eine `GET`-Anfrage an die Ressource `transactions/<transaction-id>/documents/<document-id>/sourceFiles/<file-id>/download` und geben Sie die Bezeichner des Vorgangs, des Documents und der Datei an (aus der letzten Antwort):

<VantageRegion>
  ```
  GET https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents/document-id/sourceFiles/file-id/download
  ```
</VantageRegion>

Führen Sie den folgenden Befehl aus:

<VantageRegion>
  ```bash theme={null}
  curl -X GET "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/documents/document-id/sourceFiles/file-id/download" \
  -H "Authorization: Bearer token"
  ```
</VantageRegion>

Die Antwort enthält die Datei im Binärformat. Wiederholen Sie diesen Schritt für alle Ihre Quelldateien.

<div id="result-files">
  #### Ergebnisdateien
</div>

Um eine Ergebnisdatei herunterzuladen, senden Sie eine `GET`-Anfrage an die Ressource `transactions/<transaction-id>/files/<file-id>/download` und geben Sie die Vorgangs-ID sowie die `fileId` der Ergebnisdatei an. Rufen Sie die `fileId` aus dem `resultFiles`-Array ab, das beim [Überwachen des Vorgangsstatus](#monitoring-the-transaction-status) zurückgegeben wird (jeder Eintrag hat eine `fileId` und einen `type`, z. B. `Json`):

<VantageRegion>
  ```
  GET https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/files/file-id/download
  ```
</VantageRegion>

Führen Sie den folgenden Befehl aus:

<VantageRegion>
  ```bash theme={null}
  curl -X GET "https://vantage-us.abbyy.com/api/publicapi/v1/transactions/transaction-id/files/file-id/download" \
  -H "Authorization: Bearer token"
  ```
</VantageRegion>