package main

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

const (
  apiKey = "your_api_key_here"
  apiURL = "https://api.valitract.com/api/v1/extract-generic"
)

type OCRResponse struct {
  FileName      string `json:"file_name"`
  ExtractedData map[string]interface{} `json:"extracted_data"`
}

func processOCR(filePath string) (*OCRResponse, error) {
  file, err := os.Open(filePath)
  if err != nil {
    return nil, err
  }
  defer file.Close()

  body := &bytes.Buffer{}
  writer := multipart.NewWriter(body)
  part, _ := writer.CreateFormFile("file", filePath)
  io.Copy(part, file)
  writer.Close()

  req, _ := http.NewRequest("POST", apiURL, body)
  req.Header.Set("Authorization", "Bearer "+apiKey)
  req.Header.Set("Content-Type", writer.FormDataContentType())

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

  var result OCRResponse
  json.NewDecoder(resp.Body).Decode(&result)
  return &result, nil
}

func main() {
  result, err := processOCR("document.pdf")
  if err != nil {
    fmt.Println("Error:", err)
    return
  }
  fmt.Printf("Extracted Data: %+v\n", result)
}

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

const API_KEY = 'your_api_key_here';
const API_URL = 'https://api.valitract.com/api/v1/extract-generic';

async function processOCR(filePath) {
  try {
    const form = new FormData();
    form.append('file', fs.createReadStream(filePath));

    const response = await axios.post(API_URL, form, {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        ...form.getHeaders()
      }
    });

    console.log('Extracted Data:', response.data);
    return response.data;
  } catch (error) {
    console.error('Error processing OCR:', error.message);
    throw error;
  }
}

// Usage
processOCR('document.pdf')
  .then(data => console.log('Success:', data))
  .catch(err => console.error('Failed:', err));

<?php

define('API_KEY', 'your_api_key_here');
define('API_URL', 'https://api.valitract.com/api/v1/extract-generic');

function processOCR($filePath) {
  if (!file_exists($filePath)) {
    throw new Exception("File not found: $filePath");
  }

  $ch = curl_init();
  
  $cfile = new CURLFile($filePath, mime_content_type($filePath), basename($filePath));
  
  $data = [
    'file' => $cfile
  ];

  curl_setopt_array($ch, [
    CURLOPT_URL => API_URL,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => $data,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
      'Authorization: Bearer ' . API_KEY
    ]
  ]);

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

  if ($httpCode === 200) {
    return json_decode($response, true);
  } else {
    throw new Exception("API Error: $response");
  }
}

// Usage
try {
  $result = processOCR('document.pdf');
  echo "Extracted Data:\n";
  print_r($result);
} catch (Exception $e) {
  echo "Error: " . $e->getMessage();
}

?>

import requests
import json

API_KEY = 'your_api_key_here'
API_URL = 'https://api.valitract.com/api/v1/extract-generic'

def process_ocr(file_path):
  """
  Process OCR on a document using Valitract API
  
  Args:
    file_path (str): Path to the document file
    
  Returns:
    dict: Extracted data from the document
  """
  headers = {
    'Authorization': f'Bearer {API_KEY}'
  }
  
  with open(file_path, 'rb') as file:
    files = {
      'file': (file_path, file, 'application/pdf')
    }
    
    try:
      response = requests.post(API_URL, headers=headers, files=files)
      response.raise_for_status()
      
      result = response.json()
      return result
      
    except requests.exceptions.RequestException as e:
      print(f'Error processing OCR: {e}')
      raise

# Usage
if __name__ == '__main__':
  try:
    data = process_ocr('document.pdf')
    print('Extracted Data:')
    print(json.dumps(data, indent=2))
  except Exception as e:
    print(f'Failed to process document: {e}')

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

API_KEY = 'your_api_key_here'
API_URL = 'https://api.valitract.com/api/v1/extract-generic'

def process_ocr(file_path)
  uri = URI.parse(API_URL)
  
  File.open(file_path, 'rb') do |file|
    request = Net::HTTP::Post.new(uri)
    request['Authorization'] = "Bearer #{API_KEY}"
    
    boundary = "-----------RubyMultipartBoundary"
    request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
    
    post_body = []
    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
    post_body << "\r\n--#{boundary}--\r\n"
    
    request.body = post_body.join
    
    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end
    
    if response.code == '200'
      JSON.parse(response.body)
    else
      raise "API Error: #{response.body}"
    end
  end
end

# Usage
begin
  result = process_ocr('document.pdf')
  puts "Extracted Data:"
  puts JSON.pretty_generate(result)
rescue StandardError => e
  puts "Error: #{e.message}"
end

using System;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace ValitractOCR
{
  public class OCRClient
  {
    private const string API_KEY = "your_api_key_here";
    private const string API_URL = "https://api.valitract.com/api/v1/extract-generic";

    public static async Task<string> ProcessOCR(string filePath)
    {
      using (var client = new HttpClient())
      {
        client.DefaultRequestHeaders.Authorization = 
          new AuthenticationHeaderValue("Bearer", API_KEY);

        using (var form = new MultipartFormDataContent())
        {
          var fileContent = new ByteArrayContent(
            File.ReadAllBytes(filePath)
          );
          fileContent.Headers.ContentType = 
            MediaTypeHeaderValue.Parse("application/pdf");
          
          form.Add(fileContent, "file", Path.GetFileName(filePath));

          var response = await client.PostAsync(API_URL, form);
          response.EnsureSuccessStatusCode();

          var result = await response.Content.ReadAsStringAsync();
          return result;
        }
      }
    }

    public static async Task Main(string[] args)
    {
      try
      {
        var result = await ProcessOCR("document.pdf");
        Console.WriteLine("Extracted Data:");
        
        var formatted = JsonConvert.DeserializeObject(result);
        Console.WriteLine(
          JsonConvert.SerializeObject(formatted, Formatting.Indented)
        );
      }
      catch (Exception ex)
      {
        Console.WriteLine($"Error: {ex.Message}");
      }
    }
  }
}