API Documentation

curl -X POST "https://api.deepreadocr.com/api/v1/download/signed-url?file_path=table/sales_table.json" \
  -H "X-API-Key: your_api_key_here"

# Response includes signed URL
# Download the file using the URL
curl -o result.json "$DOWNLOAD_URL"

import requests
import time
from pathlib import Path

class DeepReadOCR:
    def __init__(self, api_key, base_url="https://api.deepreadocr.com/api/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {"X-API-Key": api_key}
    
    def list_modes(self):
        """List available OCR modes."""
        response = requests.get(f"{self.base_url}/ocr-modes", headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def process_image(self, image_path, mode="ocr", poll_interval=2):
        """Process an image with OCR and return results."""
        filename = Path(image_path).name
        content_type = self._get_content_type(Path(image_path).suffix)
        
        # Step 1: Get upload URL
        response = requests.post(
            f"{self.base_url}/upload/signed-url",
            headers=self.headers,
            params={"mode": mode}
        )
        response.raise_for_status()
        upload_data = response.json()
        
        # Step 2: Upload to S3
        with open(image_path, "rb") as f:
            form_data = upload_data['fields'].copy()
            # Replace placeholder in key
            key = form_data.get('key', '').replace('${filename}', filename)
            form_data['key'] = key
            form_data['Content-Type'] = content_type
            
            requests.post(
                upload_data['url'],
                data=form_data,
                files={'file': (filename, f, content_type)}
            )
        
        # Step 3: Poll for completion
        base_name = filename.rsplit('.', 1)[0]
        while True:
            response = requests.get(
                f"{self.base_url}/processing-jobs",
                headers=self.headers,
                params={"filename": base_name, "mode": mode}
            )
            jobs = response.json()
            
            # Find our job
            for job in jobs['files']:
                if job['status'] == 'completed' and job['output_key']:
                    # Step 4: Download result
                    dl_resp = requests.post(
                        f"{self.base_url}/download/signed-url",
                        headers=self.headers,
                        params={"file_path": job['output_key']}
                    )
                    download_url = dl_resp.json()['url']
                    result = requests.get(download_url).json()
                    return result
            
            time.sleep(poll_interval)
    
    def _get_content_type(self, extension):
        types = {
            ".png": "image/png",
            ".jpg": "image/jpeg",
            ".jpeg": "image/jpeg",
            ".bmp": "image/bmp",
            ".pdf": "application/pdf"
        }
        return types.get(extension.lower(), "application/octet-stream")

# Usage
ocr = DeepReadOCR(api_key="your_api_key_here")

# List modes
modes = ocr.list_modes()
print("Available modes:", [m["name"] for m in modes])

# Process an image
result = ocr.process_image("document.png", mode="table")
print("Mode used:", result["mode"])
print("Extracted text:", result["extracted_text"])
print("Tokens:", result["usage"]["total_tokens"])

const axios = require('axios');
const fs = require('fs');
const path = require('path');
const FormData = require('form-data');

class DeepReadOCR {
  constructor(apiKey, baseURL = 'https://api.deepreadocr.com/api/v1') {
    this.apiKey = apiKey;
    this.baseURL = baseURL;
    this.headers = { 'X-API-Key': apiKey };
  }

  async listModes() {
    const response = await axios.get(`${this.baseURL}/ocr-modes`, {
      headers: this.headers
    });
    return response.data;
  }

  async processImage(imagePath, mode = 'ocr', pollInterval = 2000) {
    const fileName = path.basename(imagePath);
    const contentType = this.getContentType(path.extname(imagePath));
    
    // Get upload URL
    const uploadResponse = await axios.post(
      `${this.baseURL}/upload/signed-url?mode=${mode}`,
      null,
      { headers: this.headers }
    );
    
    const { url, fields, key_prefix } = uploadResponse.data;
    
    // Upload to S3
    const form = new FormData();
    Object.keys(fields).forEach(key => {
      let value = fields[key];
      if (key === 'key') value = value.replace('${filename}', fileName);
      form.append(key, value);
    });
    form.append('Content-Type', contentType);
    form.append('file', fs.createReadStream(imagePath));
    
    await axios.post(url, form, { headers: form.getHeaders() });
    
    // Poll for completion
    const baseName = fileName.replace(/\.[^/.]+$/, '');
    while (true) {
      const jobsResp = await axios.get(`${this.baseURL}/processing-jobs`, {
        headers: this.headers,
        params: { filename: baseName, mode }
      });
      
      const job = jobsResp.data.files.find(j => 
        j.status === 'completed' && j.mode === mode
      );
      
      if (job) {
        // Download result
        const dlResp = await axios.post(
          `${this.baseURL}/download/signed-url`,
          null,
          { headers: this.headers, params: { file_path: job.output_key } }
        );
        
        const result = await axios.get(dlResp.data.url);
        return result.data;
      }
      
      await new Promise(resolve => setTimeout(resolve, pollInterval));
    }
  }

  getContentType(extension) {
    const types = {
      '.png': 'image/png',
      '.jpg': 'image/jpeg',
      '.jpeg': 'image/jpeg',
      '.bmp': 'image/bmp',
      '.pdf': 'application/pdf'
    };
    return types[extension.toLowerCase()] || 'application/octet-stream';
  }
}

// Usage
(async () => {
  const ocr = new DeepReadOCR('your_api_key_here');
  
  const modes = await ocr.listModes();
  console.log('Available modes:', modes.map(m => m.name));
  
  const result = await ocr.processImage('./document.png', 'table');
  console.log('Mode used:', result.mode);
  console.log('Extracted text:', result.extracted_text);
  console.log('Tokens:', result.usage.total_tokens);
})();

#!/bin/bash

API_KEY="your_api_key_here"
BASE_URL="https://api.deepreadocr.com/api/v1"
IMAGE_FILE="document.png"
MODE="table"

# Get upload URL
UPLOAD_RESPONSE=$(curl -s -X POST "${BASE_URL}/upload/signed-url?mode=${MODE}" \
  -H "X-API-Key: ${API_KEY}")

UPLOAD_URL=$(echo "$UPLOAD_RESPONSE" | jq -r '.url')
KEY=$(echo "$UPLOAD_RESPONSE" | jq -r '.fields.key' | sed "s/\${filename}/${IMAGE_FILE}/")

echo "Uploading to: ${KEY}"

# Upload to S3 (multipart form)
curl -X POST "${UPLOAD_URL}" \
  -F "key=${KEY}" \
  -F "AWSAccessKeyId=$(echo "$UPLOAD_RESPONSE" | jq -r '.fields.AWSAccessKeyId')" \
  -F "policy=$(echo "$UPLOAD_RESPONSE" | jq -r '.fields.policy')" \
  -F "signature=$(echo "$UPLOAD_RESPONSE" | jq -r '.fields.signature')" \
  -F "Content-Type=image/png" \
  -F "file=@${IMAGE_FILE}"

# Poll for completion
BASE_NAME="${IMAGE_FILE%.*}"
while true; do
  JOBS=$(curl -s "${BASE_URL}/processing-jobs?filename=${BASE_NAME}&mode=${MODE}" \
    -H "X-API-Key: ${API_KEY}")
  
  STATUS=$(echo "$JOBS" | jq -r '.files[0].status')
  echo "Status: ${STATUS}"
  
  if [ "$STATUS" = "completed" ]; then
    OUTPUT_KEY=$(echo "$JOBS" | jq -r '.files[0].output_key')
    
    # Get download URL
    DOWNLOAD=$(curl -s -X POST "${BASE_URL}/download/signed-url?file_path=${OUTPUT_KEY}" \
      -H "X-API-Key: ${API_KEY}")
    
    DOWNLOAD_URL=$(echo "$DOWNLOAD" | jq -r '.url')
    
    # Download and display result
    curl -s "$DOWNLOAD_URL" | jq
    break
  fi
  
  sleep 2
done