Unsere Analysegeräte erkennen eindeutige Feldwerte aus hochgeladenen Dokumenten intelligent und ermitteln diese automatisch.
Erkennen Sie die Sprache gescannter oder gedruckter Dokumente, Bilder und PDF-Dateien.
Konvertieren Sie gescannte oder gedruckte Dokumente, einschließlich Bilder und PDF-Dateien, in maschinenlesbaren Text.
Unsere Dokumentenanalysatoren können in bestehende Softwaresysteme oder Arbeitsprozesse integriert werden.
Parse Documents ist ein robuster Satz von APIs, die alle Anforderungen an die Dokumentanalyse erfüllen. Unser Ziel ist es, den komplexen Prozess der Dokumentenverwaltung zu vereinfachen, sei es das Suchen, Analysieren oder Behandeln von Fehlern. Dazu gehören eine einfache Seitensortierung, eine große Auswahl an unterstützten Dokumenttypen und eine gründliche Fehlerberichterstattung.
Mithilfe unserer verschiedenen APIs können Sie nicht nur hochgeladene Dokumente lesen, sondern Dokumente auch per direktem Upload oder externem Link zur Analyse in die Warteschlange stellen. Unsere APIs wurden unter Berücksichtigung der dynamischen Natur des Geschäfts entwickelt und ermöglichen eine nahtlose Anpassung an eine Vielzahl von Geschäftsanforderungen und -konfigurationen.
APIs sind gemäß der OpenAPI-Spezifikation (OAS) codiert, was den Integrationsprozess problemlos und einfach macht. Wir stellen eine umfangreiche Dokumentation auf Basis der Swagger-Benutzeroberfläche bereit, die mögliche Antworten sowie mögliche Status- und Fehlercodes detailliert beschreibt.
Alle API-Anfragen werden für maximale Sicherheit mithilfe von JWT-Headern authentifiziert. Dadurch ist sichergestellt, dass Ihre sensiblen Dokumentendaten stets geschützt sind.
Wir freuen uns, Sie an Bord zu haben und können es kaum erwarten zu sehen, wie Sie die Vorteile von Parse Documents in Ihre Dokumentenverwaltungsvorgänge integrieren und maximieren!
POST /v1/documents/languages
A POST method that identifies the languages of the provided document text. This method takes the document text as input and returns the identified languages along with their probabilities.
POST /v1/documents/languages
{ "text": "Lorem ipsum dolor sit amet, consectetur adipiscing elit." }
import requests url = "https://%(baseUrl)s/v1/documents/languages" headers = { "Authorization": "Bearer {YOUR_API_KEY}" } payload = { "text": "Lorem ipsum dolor sit amet, consectetur adipiscing elit." } response = requests.post(url, headers=headers, json=payload) response.raise_for_status() identified_languages = response.json() for lang in identified_languages: print(f"Language: {lang['code']} - Probability: {lang['probability']}")
package main import ( "fmt" "net/http" "bytes" "encoding/json" ) func main() { identifyDocumentLanguages() } func identifyDocumentLanguages() { url := "https://%(baseUrl)s/v1/documents/languages" apiKey := "{YOUR_API_KEY}" payload := map[string]interface{}{ "text": "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", } requestBody, _ := json.Marshal(payload) req, _ := http.NewRequest("POST", url, bytes.NewBuffer(requestBody)) req.Header.Set("Authorization", "Bearer "+apiKey) req.Header.Set("Content-Type", "application/json") client := &http.Client{} response, _ := client.Do(req) identifiedLanguages := []map[string]interface{}{} json.NewDecoder(response.Body).Decode(&identifiedLanguages) for _, lang := range identifiedLanguages { fmt.Printf("Language: %v - Probability: %v\n", lang["code"], lang["probability"]) } }
<?php $curl = curl_init(); curl_setopt_array($curl, [ CURLOPT_URL => "https://%(baseUrl)s/v1/documents/languages", CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true, CURLOPT_POSTFIELDS => json_encode([ "text" => "Lorem ipsum dolor sit amet, consectetur adipiscing elit." ]), CURLOPT_HTTPHEADER => [ "Authorization: Bearer {YOUR_API_KEY}", "Content-Type: application/json" ], ]); $response = curl_exec($curl); $error = curl_error($curl); curl_close($curl); if ($error) { echo "Error: " . $error; } else { $identifiedLanguages = json_decode($response, true); foreach ($identifiedLanguages as $lang) { echo "Language: " . $lang['code'] . " - Probability: " . $lang['probability'] . "\n"; } }
using System; using System.Net.Http; using System.Text; using System.Text.Json; using System.Threading.Tasks; class Program { private static readonly HttpClient client = new HttpClient(); private static readonly string BASE_URL = "{YOUR_API_BASE_URL}"; private static readonly string API_KEY = "{YOUR_API_KEY}"; static void Main(string[] args) { IdentifyDocumentLanguages().Wait(); } private static async Task IdentifyDocumentLanguages() { try { client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", API_KEY); var requestBody = new { text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit." }; var requestContent = new StringContent(JsonSerializer.Serialize(requestBody), Encoding.UTF8, "application/json"); var response = await client.PostAsync(BASE_URL + "/v1/documents/languages", requestContent); response.EnsureSuccessStatusCode(); var responseBody = await response.Content.ReadAsStringAsync(); var identifiedLanguages = JsonSerializer.Deserialize<IdentifyLanguage[]>(responseBody); foreach (var lang in identifiedLanguages) { Console.WriteLine($"Language: {lang.code} - Probability: {lang.probability}"); } } catch (HttpRequestException e) { Console.WriteLine($"Error: {e.Message}"); } } }
In this code, we define a simple program with a single method `IdentifyDocumentLanguages`.
This method first sets up the authentication header by adding the bearer token to the HttpClient's default headers.
Then, it creates the request body containing the document text.
It sends a POST request to the specified endpoint with the request body as JSON.
If the request fails for any reason, an HttpRequestException will be thrown and the method will catch it and print the error message to the console.
If the request is successful, the method will read the response body as an array of `IdentifyLanguage` objects and print the language code and probability for each identified language.
Request Body:
text
: The document text to identify the languages.