# Get job result
curl -X GET https://api.leapocr.com/api/v1/ocr/result/job_abc123 \
  -H "X-API-Key: your-api-key"

# Response: (see Response section below for full example)
# {
#   "job_id": "job_abc123",
#   "status": "completed",
#   "credits_used": 3,
#   "file_name": "invoice.pdf",
#   "model": "standard-v1",
#   "result_format": "structured",
#   "total_pages": 1,
#   "processed_pages": 1,
#   "pages": [...]
# }

import { LeapOCR } from "leapocr";

const client = new LeapOCR({
  apiKey: process.env.LEAPOCR_API_KEY,
});

// Wait for job to complete
const status = await client.ocr.waitUntilDone(jobId);

if (status.status === "completed") {
  // Get the results
  const result = await client.ocr.getJobResult(jobId);

  console.log(`Credits used: ${result.credits_used}`);
  console.log(`Total pages: ${result.total_pages}`);
  console.log(`Processing time: ${result.processing_time_seconds}s`);

  // Access extracted data
  result.pages.forEach((page) => {
    console.log(`Page ${page.page_number}:`, page.result);
  });
}

import asyncio
import os
from leapocr import LeapOCR

async def main():
    async with LeapOCR(os.getenv("LEAPOCR_API_KEY")) as client:
        # Wait for job to complete
        status = await client.ocr.wait_until_done(job_id)

        if status.status.value == "completed":
            # Get the results
            result = await client.ocr.get_results(job_id)

            print(f"Credits used: {result.credits_used}")
            print(f"Total pages: {result.total_pages}")
            print(f"Model: {result.model}")

            # Access extracted data
            for page in result.pages:
                if isinstance(page.result, dict):
                    print(f"Page {page.page_number} (structured):", page.result)
                else:
                    print(f"Page {page.page_number} (markdown):", page.result[:100])

asyncio.run(main())

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "github.com/leapocr/leapocr-go"
)

func main() {
    client, err := ocr.New(os.Getenv("LEAPOCR_API_KEY"))
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // Wait for job to complete
    result, err := client.WaitUntilDone(ctx, jobID)
    if err != nil {
        log.Fatal(err)
    }

    // Get the full results
    fullResult, err := client.GetJobResult(ctx, jobID)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Credits used: %d\n", fullResult.Credits)
    fmt.Printf("Total pages: %d\n", fullResult.TotalPages)
    fmt.Printf("Processing time: %.2fs\n", fullResult.Duration)

    // Access extracted data
    fmt.Printf("Extracted data: %+v\n", fullResult.Data)
}

# Get first 50 pages
curl -X GET "https://api.leapocr.com/api/v1/ocr/result/job_abc123?page=1&limit=50" \
  -H "X-API-Key: your-api-key"

# Get next page
curl -X GET "https://api.leapocr.com/api/v1/ocr/result/job_abc123?page=2&limit=50" \
  -H "X-API-Key: your-api-key"

// Get first 50 pages
const result = await client.ocr.getJobResult(jobId, {
  page: 1,
  pageSize: 50,
});

console.log(`Total pages: ${result.pagination.total}`);
console.log(`Current page: ${result.pagination.page}`);

// Get next page
if (result.pagination.page < result.pagination.total_pages) {
  const nextPage = await client.ocr.getJobResult(jobId, {
    page: 2,
    pageSize: 50,
  });
}

# Get first 50 pages
result = await client.ocr.get_results(job_id, page=1, limit=50)

print(f"Total pages: {result.pagination.total}")
print(f"Current page: {result.pagination.page}")

# Get next page
if result.pagination.page < result.pagination.total_pages:
    next_page = await client.ocr.get_results(job_id, page=2, limit=50)

// Get first 50 pages
result, err := client.GetJobResult(ctx, jobID, ocr.WithPage(1), ocr.WithLimit(50))
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Total pages: %d\n", result.Pagination.Total)
fmt.Printf("Current page: %d\n", result.Pagination.Page)

// Get next page
if result.Pagination.Page < result.Pagination.TotalPages {
    nextPage, _ := client.GetJobResult(ctx, jobID, ocr.WithPage(2), ocr.WithLimit(50))
}