API Documentation

import requests
import json

url = "https://applyocr.com/api/v1/ocr/process"
api_key = "your_api_key_here"

# Open file in binary mode
with open("document.pdf", "rb") as file:
    files = {"file": file}
    headers = {"X-API-Key": api_key}

    # Optional: Add processing options
    data = {
        "options": json.dumps({
            "enable_table_extraction": True,
            "confidence_threshold": 0.7
        })
    }

    response = requests.post(url, headers=headers, files=files, data=data)

    if response.status_code == 200:
        result = response.json()
        print(f"Extracted text: {result['full_text']}")
        print(f"Pages processed: {result['document_metadata']['pages']}")
    else:
        print(f"Error: {response.status_code} - {response.text}")

const apiKey = 'your_api_key_here';
const file = document.getElementById('fileInput').files[0];

// Create form data
const formData = new FormData();
formData.append('file', file);

// Optional: Add processing options
const options = {
    enable_table_extraction: true,
    confidence_threshold: 0.7
};
formData.append('options', JSON.stringify(options));

// Send request
try {
    const response = await fetch('https://applyocr.com/api/v1/ocr/process', {
        method: 'POST',
        headers: {
            'X-API-Key': apiKey
        },
        body: formData
    });

    if (response.ok) {
        const result = await response.json();
        console.log('Extracted text:', result.full_text);
        console.log('Pages processed:', result.document_metadata.pages);
    } else {
        const error = await response.json();
        console.error('Error:', error);
    }
} catch (error) {
    console.error('Request failed:', error);
}

import okhttp3.*;
import java.io.File;
import java.io.IOException;

public class OCRClient {
    private static final String API_URL = "https://applyocr.com/api/v1/ocr/process";
    private static final String API_KEY = "your_api_key_here";

    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();

        File file = new File("document.pdf");

        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("file", file.getName(),
                RequestBody.create(file, MediaType.parse("application/pdf")))
            .addFormDataPart("options",
                "{\"enable_table_extraction\": true, \"confidence_threshold\": 0.7}")
            .build();

        Request request = new Request.Builder()
            .url(API_URL)
            .addHeader("X-API-Key", API_KEY)
            .post(requestBody)
            .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                String responseBody = response.body().string();
                System.out.println("Success: " + responseBody);
            } else {
                System.out.println("Error: " + response.code());
            }
        }
    }
}

<?php

$apiUrl = 'https://applyocr.com/api/v1/ocr/process';
$apiKey = 'your_api_key_here';
$filePath = 'document.pdf';

$ch = curl_init();

$file = new CURLFile($filePath);

$options = json_encode([
    'enable_table_extraction' => true,
    'confidence_threshold' => 0.7
]);

$postData = [
    'file' => $file,
    'options' => $options
];

curl_setopt_array($ch, [
    CURLOPT_URL => $apiUrl,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $postData,
    CURLOPT_HTTPHEADER => [
        'X-API-Key: ' . $apiKey
    ]
]);

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

if ($httpCode === 200) {
    $result = json_decode($response, true);
    echo "Extracted text: " . $result['full_text'] . "\n";
    echo "Pages: " . $result['document_metadata']['pages'] . "\n";
} else {
    echo "Error: HTTP $httpCode - $response\n";
}

curl_close($ch);
?>

require 'net/http'
require 'uri'
require 'json'

api_url = URI('https://applyocr.com/api/v1/ocr/process')
api_key = 'your_api_key_here'
file_path = 'document.pdf'

boundary = "----WebKitFormBoundary#{rand(1000000000)}"
post_body = []

# Add file
post_body << "--#{boundary}\r\n"
post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(file_path)}\"\r\n"
post_body << "Content-Type: application/pdf\r\n\r\n"
post_body << File.read(file_path)
post_body << "\r\n"

# Add options
options = {
  enable_table_extraction: true,
  confidence_threshold: 0.7
}
post_body << "--#{boundary}\r\n"
post_body << "Content-Disposition: form-data; name=\"options\"\r\n\r\n"
post_body << options.to_json
post_body << "\r\n--#{boundary}--\r\n"

request = Net::HTTP::Post.new(api_url)
request['X-API-Key'] = api_key
request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
request.body = post_body.join

response = Net::HTTP.start(api_url.hostname, api_url.port, use_ssl: true) do |http|
  http.request(request)
end

if response.code == '200'
  result = JSON.parse(response.body)
  puts "Extracted text: #{result['full_text']}"
  puts "Pages: #{result['document_metadata']['pages']}"
else
  puts "Error: #{response.code} - #{response.body}"
end

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    apiURL := "https://applyocr.com/api/v1/ocr/process"
    apiKey := "your_api_key_here"
    filePath := "document.pdf"

    // Create multipart form
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // Add file
    file, err := os.Open(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    part, err := writer.CreateFormFile("file", filePath)
    if err != nil {
        panic(err)
    }
    io.Copy(part, file)

    // Add options
    options := map[string]interface{}{
        "enable_table_extraction": true,
        "confidence_threshold":    0.7,
    }
    optionsJSON, _ := json.Marshal(options)
    writer.WriteField("options", string(optionsJSON))

    writer.Close()

    // Create request
    req, err := http.NewRequest("POST", apiURL, body)
    if err != nil {
        panic(err)
    }

    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Parse response
    if resp.StatusCode == 200 {
        var result map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&result)

        fmt.Printf("Extracted text: %v\n", result["full_text"])
        metadata := result["document_metadata"].(map[string]interface{})
        fmt.Printf("Pages: %v\n", metadata["pages"])
    } else {
        bodyBytes, _ := io.ReadAll(resp.Body)
        fmt.Printf("Error: %d - %s\n", resp.StatusCode, string(bodyBytes))
    }
}

import requests

url = "https://applyocr.com/api/v1/ocr/batch"
api_key = "your_api_key_here"

with open("documents.zip", "rb") as file:
    files = {"file": file}
    headers = {"X-API-Key": api_key}

    response = requests.post(url, headers=headers, files=files)

    if response.status_code == 200:
        result = response.json()
        print(f"Total documents: {result['total_documents']}")
        print(f"Successful: {result['successful']}")
        print(f"Failed: {result['failed']}")

        # Process individual documents
        for doc in result['documents']:
            print(f"\n{doc['document_metadata']['filename']}:")
            print(f"  Text: {doc['full_text'][:100]}...")
    else:
        print(f"Error: {response.status_code}")

const apiKey = 'your_api_key_here';
const zipFile = document.getElementById('zipInput').files[0];

const formData = new FormData();
formData.append('file', zipFile);

try {
    const response = await fetch('https://applyocr.com/api/v1/ocr/batch', {
        method: 'POST',
        headers: {
            'X-API-Key': apiKey
        },
        body: formData
    });

    if (response.ok) {
        const result = await response.json();
        console.log(`Processed ${result.successful}/${result.total_documents} documents`);

        result.documents.forEach(doc => {
            console.log(`${doc.document_metadata.filename}: ${doc.full_text.substring(0, 100)}...`);
        });
    }
} catch (error) {
    console.error('Batch processing failed:', error);
}

<?php

$apiUrl = 'https://applyocr.com/api/v1/ocr/batch';
$apiKey = 'your_api_key_here';
$zipPath = 'documents.zip';

$ch = curl_init();

$file = new CURLFile($zipPath);

curl_setopt_array($ch, [
    CURLOPT_URL => $apiUrl,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => ['file' => $file],
    CURLOPT_HTTPHEADER => ['X-API-Key: ' . $apiKey]
]);

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

if ($httpCode === 200) {
    $result = json_decode($response, true);
    echo "Processed: {$result['successful']}/{$result['total_documents']} documents\n";

    foreach ($result['documents'] as $doc) {
        $filename = $doc['document_metadata']['filename'];
        $preview = substr($doc['full_text'], 0, 100);
        echo "\n$filename: $preview...\n";
    }
} else {
    echo "Error: HTTP $httpCode - $response\n";
}

curl_close($ch);
?>

require 'net/http'
require 'uri'
require 'json'

api_url = URI('https://applyocr.com/api/v1/ocr/batch')
api_key = 'your_api_key_here'
zip_path = 'documents.zip'

boundary = "----WebKitFormBoundary#{rand(1000000000)}"
post_body = []

# Add ZIP file
post_body << "--#{boundary}\r\n"
post_body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{File.basename(zip_path)}\"\r\n"
post_body << "Content-Type: application/zip\r\n\r\n"
post_body << File.read(zip_path)
post_body << "\r\n--#{boundary}--\r\n"

request = Net::HTTP::Post.new(api_url)
request['X-API-Key'] = api_key
request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
request.body = post_body.join

response = Net::HTTP.start(api_url.hostname, api_url.port, use_ssl: true) do |http|
  http.request(request)
end

if response.code == '200'
  result = JSON.parse(response.body)
  puts "Processed: #{result['successful']}/#{result['total_documents']} documents"

  result['documents'].each do |doc|
    filename = doc['document_metadata']['filename']
    preview = doc['full_text'][0..99]
    puts "\n#{filename}: #{preview}..."
  end
else
  puts "Error: #{response.code} - #{response.body}"
end

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    apiURL := "https://applyocr.com/api/v1/ocr/batch"
    apiKey := "your_api_key_here"
    zipPath := "documents.zip"

    // Create multipart form
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // Add ZIP file
    file, err := os.Open(zipPath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    part, err := writer.CreateFormFile("file", zipPath)
    if err != nil {
        panic(err)
    }
    io.Copy(part, file)

    writer.Close()

    // Create request
    req, err := http.NewRequest("POST", apiURL, body)
    if err != nil {
        panic(err)
    }

    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    // Send request
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // Parse response
    if resp.StatusCode == 200 {
        var result map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&result)

        fmt.Printf("Processed: %.0f/%.0f documents\n",
            result["successful"], result["total_documents"])

        documents := result["documents"].([]interface{})
        for _, doc := range documents {
            docMap := doc.(map[string]interface{})
            metadata := docMap["document_metadata"].(map[string]interface{})
            text := docMap["full_text"].(string)

            fmt.Printf("\n%s: %s...\n",
                metadata["filename"], text[:min(100, len(text))])
        }
    } else {
        bodyBytes, _ := io.ReadAll(resp.Body)
        fmt.Printf("Error: %d - %s\n", resp.StatusCode, string(bodyBytes))
    }
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}