Advanced Options

import { zerox } from 'zerox-ocr';

const result = await zerox({
  filePath: 'report.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  maintainFormat: true  // Preserve formatting across pages
});

// Internal behavior (simplified)
let priorPage = "";

for (const page of pages) {
  const result = await processPage(page, {
    prompt: `Maintain consistent formatting with: ${priorPage}`
  });
  priorPage = result.content;
}

const result = await zerox({
  filePath: 'scanned-document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  correctOrientation: true  // Default: true
});

// Determines optimal rotation (0°, 90°, 180°, 270°)
const rotation = await determineOptimalRotation(image);
console.log(`Rotating image ${rotation} degrees`);

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  trimEdges: true  // Default: true
});

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  imageFormat: 'jpeg'  // 'png' (default) or 'jpeg'
});

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  imageDensity: 300  // DPI (dots per inch)
});

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  imageHeight: 2048  // Height in pixels
});

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  maxImageSize: 10  // Maximum size in MB
});

// Starts at 90% quality, reduces by 10% until target size is reached
let quality = 90;
while (imageSize > maxSize && quality >= 20) {
  compressedImage = await compress(image, quality);
  quality -= 10;
}

// Process single page
const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  pagesToConvertAsImages: 5  // Only page 5
});

// Process multiple pages
const result2 = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  pagesToConvertAsImages: [1, 3, 5, 7]  // Specific pages
});

// Process all pages (default)
const result3 = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  pagesToConvertAsImages: -1  // All pages (default)
});

const result = await zerox({
  filePath: 'large-document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  concurrency: 5  // Process 5 pages at a time
});

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  correctOrientation: true,
  maxTesseractWorkers: 8  // Maximum worker threads
});

// From constants.ts
const NUM_STARTING_WORKERS = 3;

// Workers scale based on document size
if (numPages > NUM_STARTING_WORKERS) {
  await addMoreWorkers(numPages - NUM_STARTING_WORKERS);
}

const result = await zerox({
  filePath: 'technical-doc.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  prompt: `
    Additional instructions:
    - Preserve all code blocks with syntax highlighting
    - Convert diagrams to Mermaid syntax when possible
    - Keep all mathematical equations in LaTeX format
  `
});

const SYSTEM_PROMPT_BASE = `
Convert the following document to markdown.
Return only the markdown with no explanation text.

RULES:
  - Include all information on the page
  - Return tables in HTML format
  - Interpret charts & infographics to markdown
  - Use ☐ and ☑ for checkboxes
  - Wrap logos: <logo>Brand Name</logo>
  - Wrap watermarks: <watermark>TEXT</watermark>
  - Wrap page numbers: <page_number>14</page_number>
`;

const result = await zerox({
  filePath: 'document.pdf',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  llmParams: {
    temperature: 0.1,     // Lower = more deterministic
    maxTokens: 4096,      // Maximum output tokens
    topP: 0.9,           // Nucleus sampling
    frequencyPenalty: 0,  // Penalize frequent tokens
    presencePenalty: 0,   // Penalize repeated topics
    logprobs: true        // Return log probabilities
  }
});

import { CompletionResponse } from 'zerox-ocr';

const customModel = async ({
  buffers,
  image,
  maintainFormat,
  pageNumber,
  priorPage
}) => {
  // Your custom vision model logic
  const result = await myVisionModel(buffers[0]);
  
  return {
    content: result.text,
    inputTokens: result.inputTokens,
    outputTokens: result.outputTokens
  } as CompletionResponse;
};

const result = await zerox({
  filePath: 'document.pdf',
  customModelFunction: customModel
});

import { zerox } from 'zerox-ocr';

const result = await zerox({
  // Input
  filePath: 'technical-report.pdf',
  pagesToConvertAsImages: [1, 2, 3, 4, 5],
  
  // Model configuration
  model: 'gpt-4o',
  credentials: { apiKey: process.env.OPENAI_API_KEY },
  llmParams: {
    temperature: 0.1,
    maxTokens: 4096,
    logprobs: true
  },
  
  // Image processing
  correctOrientation: true,
  trimEdges: true,
  imageFormat: 'png',
  imageDensity: 300,
  maxImageSize: 10,
  
  // OCR behavior
  maintainFormat: true,
  prompt: 'Preserve code blocks and technical diagrams',
  
  // Performance
  concurrency: 5,
  maxTesseractWorkers: 8,
  
  // Output
  outputDir: './output',
  tempDir: './temp',
  cleanup: true
});

console.log(`Processed ${result.pages.length} pages`);
console.log(`Total tokens: ${result.inputTokens + result.outputTokens}`);