HyperAPI · by Hyperbots

Turn financial documents into validated JSON

HyperAPI is a set of document intelligence APIs for invoices, receipts, bank statements, contracts and other finance documents. You send a PDF or image and get back clean text, typed fields, a document type or redacted pages. It works from a backend service, a dashboard or an AI agent.

5core endpoints
30 pages / mofree, no credit card
$0.001 / pagefast parse
Python SDKsync + async, MIT

Five endpoints. Call any of them on its own.

Each endpoint takes a document_key from a single upload, so you can chain them without uploading the file again.

Parse

POST /v1/parse

OCR to clean text and markdown with page geometry, line and word boxes, layout regions and table parsing. advanced mode adds per-page structured HTML and markdown.

from $0.001 / page

Extract

POST /v1/extract

Typed entities and line items from invoices and receipts. For any other document, pass your own JSON schema.

$0.05 / page

Classify

POST /v1/classify

Returns a document type with a confidence score and ranked candidates. You can add your own classes and descriptions.

$0.05 / page

Split

POST /v1/split

Breaks a bundled PDF into separate logical documents, with a page range, label and confidence for each.

$0.05 / page

Redact

POST /v1/redact

Covers PII with black boxes or replaces it with synthetic values. You can add your own entity types.

$0.05 / page

Quickstart

Python 3.9+. The official SDK installs from GitHub.

  1. Create a free account and generate a key at apis.hyperbots.com/dashboard/api-keys. Keys that start with hk_live_ are for production and keys that start with hk_test_ are for testing.
  2. Install the SDK and set HYPERAPI_KEY.
  3. Parse and extract in a single call.
# install (the package installs as hyperapi-sdk and imports as hyperapi)
pip install "hyperapi-sdk @ git+https://github.com/hyprbots/hyperapi-sdk.git"
export HYPERAPI_KEY=hk_test_...
from hyperapi import HyperAPIClient

with HyperAPIClient() as client:          # reads HYPERAPI_KEY
    doc = client.process("invoice.pdf")      # parse + extract in one call
    print(doc["result"])

    text  = client.parse("invoice.pdf")            # OCR text + layout
    kind  = client.classify("bundle.pdf")          # document type + confidence
    parts = client.split("bundle.pdf")             # page ranges per document
    safe  = client.redact("statement.pdf", mode="deidentify")
Don't run pip install hyperapi. That name on PyPI belongs to an unrelated project. Use the GitHub install above.

For FastAPI, aiohttp or agent loops, use AsyncHyperAPIClient and fan calls out with asyncio.gather. Every endpoint also has a submit_* variant that returns a job for bulk or long-running work. Batches are available through create_batch_from_files.

REST, from any language

The flow has three steps: request an upload URL, PUT the bytes, then call any endpoint with the document_key. The key is valid for 24 hours.

# 1. request a presigned upload URL
curl -X POST https://apis.hyperbots.com/v1/documents/upload \
  -H "X-API-Key: $HYPERAPI_KEY" -H "Content-Type: application/json" \
  -d '{"filename":"invoice.pdf","content_type":"application/pdf","content_length":184213}'
# -> {"document_key":"550e8400-...","upload_url":"https://...","expires_in":900}

# 2. upload the file to upload_url with an HTTP PUT (no API key needed)

# 3. extract structured fields
curl -X POST https://apis.hyperbots.com/v1/extract \
  -H "X-API-Key: $HYPERAPI_KEY" \
  -F "document_key=550e8400-e29b-41d4-a716-446655440000"
{
  "status": "success",
  "task": "extract",
  "model_used": "HyperLM",
  "result": {
    "entities": {
      "invoice_number": "INV-2024-0042",
      "date": "2024-01-15",
      "due_date": "2024-02-15",
      "vendor_name": "Acme Supplies Ltd",
      "total_amount": "1,250.00",
      "currency": "USD"
    },
    "line_items": [ ... ]
  }
}
# any document, your schema
curl -X POST \
 "https://apis.hyperbots.com/v1/extract?category=non_financial" \
 -H "X-API-Key: $HYPERAPI_KEY" \
 -F "document_key=..." \
 -F 'schema={"patient_name":null,"active":false}'

# dense tables and forms
# add ?parse_mode=advanced (Plus, Pro, Custom)

# process asynchronously and get a job id
-H "X-Async: true"

Pricing

Start free. Paid plans charge overage to prepaid credits at the per-page rates shown above. Results are cached per document for 24 hours, and cached results are not billed.

PlanPricePages / monthRate limitHighlights
Free$0301 req/minAll core APIs, fast parse, no credit card
Starter$130010 req/minCore APIs, email support
Plus$2510,00030 req/minAdvanced parse, team workspace with 3 seats
Pro$9950,00060 req/minPriority routing, up to 10 seats, priority support
CustomTalk to usVolumeDedicatedBYOK, IP allowlist, human-in-the-loop review

Current prices and promotions are on the pricing page.

Inputs and limits

  • PDF, PNG, JPEG, WebP, TIFF and HEIC, plus Word, Excel, PowerPoint, CSV, TXT, RTF, JSON and XML.
  • Uploads up to 50 MB (512 MiB for Custom async).
  • Fast parse, Classify and Split have no page cap. Advanced parse and advanced Extract allow 60 pages (500 for Custom async). Redact allows 36 pages.
  • GET /v1/limits returns the limits that apply to your key.

Data handling

  • Files are processed in memory and deleted when a run completes, unless you turn on retention.
  • Documents are not used for training.
  • Redact can remove PII before any downstream model sees the document.
  • Hyperbots is SOC 1 Type 2, SOC 2 Type 2 and ISO 27001 certified.

Research behind it

HyperAPI runs on Hyperbots' finance-specific models, including HyperLM and in-house vision-language models.

DocuLite

Adapting LLMs and VLMs to invoice extraction without human-annotated training data, using synthetic data generators (InvoicePy and TemplatePy). Accepted at the 4th Deployable AI Workshop, AAAI 2026.

Read the research →

Synthetic invoice dataset

A synthetic invoice set with HTML, OCR-style text and gold labels in the Extract output format. Use it to benchmark HyperAPI or your own pipeline.

Open the dataset →

Engineering blog

Posts on deterministic extraction from financial PDFs, schema-as-contract, and classifying more than 1,400 bank statement templates.

Read the blog →