Automatic document field detection

Our parsers intelligently recognizes and auto-detects unique fields from uploaded documents.

Document language detection

Detect the language in scanned or printed documents, images, and PDFs.

Optical Character Recognition (OCR)

Convert scanned or printed documents, including images and PDFs, into machine-readable text.

Integration and automation

Our document parsers can be integrated into existing software systems or workflows.

Optical Character Recognition (OCR) API

Parse Documents provides a robust suite of APIs designed to handle all your document parsing requirements. Our aim is to simplify the complex process of document management, be it retrieval, parsing, or error handling. This includes effortless pagination, a plethora of supported document types, and meticulous error detail.

Versatility and Flexibility

Through our versatile APIs, you can not just retrieve uploaded documents but also queue documents for parsing either via a direct upload or through an external link. Our APIs are designed keeping in mind the dynamic nature of businesses and therefore, they seamlessly cater to varying business needs and configurations.

Swagger Configuration

The APIs are coded following the OpenAPI Specification (OAS), making the integration process hassle-free and straightforward. We provide complete Swagger UI-based documentation that details the potential responses and possible status and error codes.

Your Security, Our Priority

All API requests are authenticated via JWT headers for maximum security. This ensures that your sensitive document data remains protected at all times.

Let's Get Started

We are thrilled to have you onboard and can't wait to see how you integrate and maximize the utility of Parse Documents in your document management operations!

Please make sure to replace "YourAuthTokenHere" with your actual bearer token.
OCR Document via URL
POST /v1/documents/ocr/url

A POST method that performs Optical Character Recognition (OCR) on a document using its URL.

Example Request
POST /v1/documents/ocr/url HTTP/1.1
Content-Type: application/json
Authorization: Bearer YourAuthTokenHere

{
    "filename": "sample.pdf",
    "url": "https://example.com/sample.pdf"
}
Request Headers
  • Content-Type: application/json
  • Authorization: Bearer YourAuthTokenHere
Request Body

The request body should be a JSON object with the following properties:

  • filename (optional): The identification of the file (filename).
  • url: The URL of the document to download and parse.
  • password (optional): Password of encrypted file.
Responses
  • 200 Success: Returns the OCR text of the document.
  • 404 Not Found: The requested document is not found.
  • 400 Bad Request: The request was made incorrectly.
import requests
import json

def ocr_document_by_url():
    try:
        headers = {
            "Authorization": "Bearer YourAuthTokenHere"
        }

        url = "https://.cargoinvoice.com/v1/documents/ocr/url"

        payload = {
            "filename": "sample.pdf",
            "url": "https://example.com/sample.pdf",
            "password": "YourPasswordHere"
        }

        response = requests.post(url, data=json.dumps(payload), headers=headers)
        response.raise_for_status()

        responseBody = response.text

        print(responseBody)
    except requests.exceptions.HTTPError as e:
        print(f"Error: {e}")

ocr_document_by_url()
package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "strings"
)

func main() {
    ocrDocumentByUrl()
}

func ocrDocumentByUrl() {
    client := &http.Client{}

    reqBody := strings.NewReader(`{
        "filename": "sample.pdf",
        "url": "https://example.com/sample.pdf",
        "password": "YourPasswordHere"
    }`)

    req, err := http.NewRequest("POST", "https://.cargoinvoice.com/v1/documents/ocr/url", reqBody)
    if err != nil {
        log.Fatalln(err)
    }

    req.Header.Add("Authorization", "Bearer YourAuthTokenHere")
    req.Header.Add("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    bodyBytes, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }

    bodyString := string(bodyBytes)
    fmt.Println(bodyString)
}
<?php

function ocrDocumentByUrl() {
    try {
        $baseUrl = ".cargoinvoice.com";
        $token = "YourAuthTokenHere";

        $url = "https://{$baseUrl}/v1/documents/ocr/url";

        $headers = array(
            "Content-Type: application/json",
            "Authorization: Bearer {$token}"
        );

        $payload = array(
            "filename" => "sample.pdf",
            "url" => "https://example.com/sample.pdf",
            "password" => "YourPasswordHere"
        );

        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        curl_close($ch);

        if ($httpCode === 200) {
            echo $response;
        } else {
            echo "Error: {$response}";
        }
    } catch (Exception $e) {
        echo "Error: {$e->getMessage()}";
    }
}

ocrDocumentByUrl();
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    private static readonly HttpClient client = new HttpClient();

    static void Main(string[] args)
    {
        OcrDocumentByUrl().Wait();
    }

    private static async Task OcrDocumentByUrl()
    {
        try
        {
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "YourAuthTokenHere");

            var requestUri = new UriBuilder("https://.cargoinvoice.com/v1/documents/ocr/url");

            var requestBody = new
            {
                filename = "sample.pdf",
                url = "https://example.com/sample.pdf",
                password = "YourPasswordHere"
            };
            var jsonBody = JsonConvert.SerializeObject(requestBody);

            var response = await client.PostAsync(requestUri.ToString(), new StringContent(jsonBody, System.Text.Encoding.UTF8, "application/json"));
            response.EnsureSuccessStatusCode();

            string responseBody = await response.Content.ReadAsStringAsync();

            Console.WriteLine(responseBody);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

In this code, we define a simple program with a single method `OcrDocumentByUrl`.

This method first sets up the authentication header by adding the bearer token to the HttpClient's default headers.

Then, it constructs the request URL using a `System.Net.UriBuilder`.

It creates an anonymous object `requestBody` with the desired request parameters and converts it to a JSON string using Newtonsoft.Json.JsonConvert.SerializeObject method.

Finally, it sends a POST request to the API by passing the request URL, request body as a `StringContent` and the "application/json" media type to the `PostAsync` method of the HttpClient.

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 a string and print it to the console.

Request Body:

  • filename (optional): The identification of the file (filename).
  • url: The URL of the document to download and parse.
  • password (optional): Password of encrypted file.
OCR Document via Base64 Encoded Binary Representation
POST /v1/documents/ocr/base64

A POST method that performs Optical Character Recognition (OCR) on a document using a base64 encoded binary representation of the document. The results will be returned as a string.

Example Request
POST /v1/documents/ocr/base64
Request Headers
  • Content-Type: application/json
  • Authorization: Bearer YourAuthTokenHere
Query Parameters
  • filename (optional): The identification of the file (filename).
  • password (optional): Password of encrypted file.
Request Body
"Base64EncodedBinaryRepresentationOfTheDocument"
                
import requests
import base64

def ocr_document():
    url = "https://.cargoinvoice.com/v1/documents/ocr/base64"
    headers = {"Authorization": "Bearer [API_KEY]"}
    params = {
        "filename": "document.pdf",
        "password": "secretpassword"
    }
    with open("document.pdf", "rb") as file:
        file_data = file.read()
        encoded_data = base64.b64encode(file_data).decode("utf-8")
        payload = {"base64": encoded_data}

        response = requests.post(url, headers=headers, params=params, json=payload)
        response.raise_for_status()

        print(response.text)

ocr_document()
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "strings"
)

func main() {
    ocrDocument()
}

func ocrDocument() {
    baseURL := "https://.cargoinvoice.com/v1/documents/ocr/base64"
    apiKey := "[API_KEY]"
    filename := "document.pdf"
    password := "secretpassword"

    fileData, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Println("Error reading file:", err)
        return
    }

    encodedData := base64.StdEncoding.EncodeToString(fileData)

    params := url.Values{}
    params.Set("filename", filename)
    params.Set("password", password)

    payload := strings.NewReader(fmt.Sprintf(`{"base64": "%s"}`, encodedData))

    client := &http.Client{}
    req, err := http.NewRequest("POST", baseURL, payload)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.URL.RawQuery = params.Encode()

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error making request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println(string(body))
}
<?php

function ocrDocument() {
    $baseUrl = "https://.cargoinvoice.com/v1/documents/ocr/base64";
    $apiKey = "[API_KEY]";
    $filename = "document.pdf";
    $password = "secretpassword";

    $fileData = file_get_contents($filename);
    $encodedData = base64_encode($fileData);

    $params = array(
        "filename" => $filename,
        "password" => $password
    );

    $query = http_build_query($params);
    $url = $baseUrl . '?' . $query;

    $headers = array(
        "Authorization: Bearer " . $apiKey,
        "Content-Type: application/json"
    );

    $payload = json_encode(array("base64" => $encodedData));

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);

    if ($response === false) {
        echo "Error: " . curl_error($ch);
    } else {
        echo $response;
    }

    curl_close($ch);
}

ocrDocument();
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    private static readonly HttpClient client = new HttpClient();

    static void Main(string[] args)
    {
        OcrDocument().Wait();
    }

    private static async Task OcrDocument()
    {
        try
        {
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", "[API_KEY]");

            var queryParams = new System.Collections.Specialized.NameValueCollection
            {
                { "filename", "document.pdf" },
                { "password", "secretpassword" }
            };

            var query = new System.Net.Http.FormUrlEncodedContent(queryParams);

            using (var fileStream = new System.IO.FileStream("document.pdf", System.IO.FileMode.Open))
            using (var content = new System.Net.Http.StreamContent(fileStream))
            {
                content.Headers.Add("Content-Type", "application/pdf");

                var response = await client.PostAsync("https://.cargoinvoice.com/v1/documents/ocr/base64" + query.ReadAsStringAsync().Result, content);
                response.EnsureSuccessStatusCode();

                string responseBody = await response.Content.ReadAsStringAsync();

                Console.WriteLine(responseBody);
            }
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

In this code, we define a simple program with a single method `OcrDocument`.

This method first sets up the authentication header by adding the bearer token to the HttpClient's default headers.

Then, it constructs the query parameters using a `System.Collections.Specialized.NameValueCollection` object.

It converts the query parameters to a `System.Net.Http.FormUrlEncodedContent` object and appends it to the request URL.

The method also constructs the request body as a string and creates a `System.Net.Http.StringContent` object with UTF8 encoding and "application/json" media type.

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 a string and print it to the console.

Query Parameters:

  • filename (optional): The identification of the file (filename).
  • password (optional): Password of encrypted file.