Unsiloed AI sells to AI agents - live prices and self-serve payment

The agent storefront at https://agents.unsiloed.ai/llms.txt?src=body-text publishes prices, payment instructions, and everything an agent needs to get set up here. Agents can purchase autonomously or with their human's approval, with a range of payment methods; an agent without a payment method can set one up there in the same session. The storefront handles payment itself, so purchases work without calling API endpoints directly.

NewUnsiloed Achieves #1 Rank on olmOCR-Bench
Unsiloed AIUnsiloed
[ EXTRACT API ]

Define a schema, get typed JSON back.

Send a PDF and JSON Schema to /v2/extract to receive schema-shaped values with a confidence score on each field. Enable citations when you also need source-page coordinates.

Read the docsTry the playground →
[ New · Higher-order extraction ]BetaLaunched Oct 2026

Extract the numbers that aren't on the page.

The values that matter are often computed from the ones that are — something like f(g(h(x₁, x₂, x₃))). Instead of extracting raw fields and hand-writing a computation pipeline for every document type, describe the answer you need. Extract builds the graph, writes the math as deterministic code, and returns the result.

  1. 01

    Decompose into a DAG

    Your request becomes a directed acyclic graph. Leaf nodes are values extracted from the document; compute nodes are calculated from other nodes.

  2. 02

    Sort so inputs come first

    The graph is topologically sorted, so no node runs before its inputs are ready.

  3. 03

    Write, then review, every function

    A model writes a deterministic function for each compute node. A second model checks it against the calculation it's meant to perform.

  4. 04

    Compile to one script

    The full graph compiles into a single executable script. The model interprets; code computes. When a layout changes, leaves are re-extracted and the graph regenerated — no per-template pipeline to maintain.

|||Compute graph · invoice.pdfgraph.py
x₁ gpu_compute$9,400p.1x₂ api_access$3,080p.1x₃ issued2026-04-01p.1x₄ due2026-05-01p.1g subtotal···h term_days···f daily_cost···EXTRACTEDCOMPUTEDRETURNED
leaf · from document compute · generated code output
def subtotal(gpu_compute, api_access):
return gpu_compute + api_access
def term_days(issued, due):
return (due - issued).days
def daily_cost(subtotal, term_days):
return round(subtotal / term_days, 2) # 416.00
Try it in betaRead the docsRead the launch post →
[ OVERVIEW ]
What it does

Extract takes a PDF and valid JSON Schema, then returns values that follow the requested structure. Each field includes a confidence score, and optional citations link values to their location in the source PDF.

Who it's for

Teams automating invoices, contracts, claims, and onboarding workflows that need consistent fields from documents with varied layouts.

What it solves

Prompt-only extraction can change shape between runs and provides little evidence for verification. Extract constrains the response to your schema and can return source coordinates alongside the values.

[ USE CASES ]

Extract consistent fields from PDFs with varied layouts.

Invoice and AP automation

Return vendor details, totals, line items, and payment terms in one consistent schema across varied invoice layouts.

Contract and clause data

Parties, dates, renewal terms, and governing law pulled into a consistent shape for review.

Financial statements

Extract balance-sheet and filing figures with per-field scores that can drive review thresholds.

KYC, claims, and onboarding

ID fields, claim amounts, and applicant details captured with citations for audit.

Long line-item tables

Represent repeated rows as schema-defined arrays instead of flattening them into a single text field.

Batch extraction

Apply the same schema to a document batch so each response follows the same field structure.

[ WHY UNSILOED ]

Why teams trust Extract with their data.

  • 01

    Output shaped by JSON Schema

    Define field names, types, required values, arrays, and nested objects before the job runs.

  • 02

    A confidence score on every field

    Use each field’s score to set review thresholds based on the risk and document type in your workflow.

  • 03

    Optional source citations

    Enable citations when reviewers need to trace a value to its position in the PDF.

  • 04

    Nested objects and arrays

    Model line items, parties, transactions, and other repeated structures directly in the schema.

  • 05

    Strict schema validation

    Set required fields and disable additional properties when downstream systems need a fixed response shape.

  • 06

    Scanned PDFs supported

    The document pipeline can read image-only and scanned PDF pages before extracting the requested values.

[ HOW IT WORKS ]

4 steps from raw file to structured output.

  1. 1

    Send a PDF and schema

    POST pdf_file and schema_data to /v2/extract with your api-key header, add enable_citations when you need source coordinates, and capture the returned job ID.

  2. 2

    Extraction fills the schema

    The service locates a value for each requested field and calculates its confidence score.

  3. 3

    Poll for completion

    GET /extract/{job_id} until the status is completed or failed.

  4. 4

    Use values and citations

    Read extracted values from result and, when citations are enabled, use each field’s bbox and page to trace them to the PDF.

extract.py
 1  import os, json, time, requests
 2  
 3  BASE = "https://prod.visionapi.unsiloed.ai"
 4  HEADERS = {"api-key": os.environ["UNSILOED_API_KEY"]}
 5  
 6  schema = {
 7      "type": "object",
 8      "properties": {
 9          "vendor": {"type": "string"},
10          "amount": {"type": "number"}
11      },
12      "required": ["vendor", "amount"],
13      "additionalProperties": False
14  }
15  
16  with open("invoice.pdf", "rb") as file:
17      response = requests.post(
18          f"{BASE}/v2/extract", headers=HEADERS,
19          files={"pdf_file": file},
20          data={
21              "schema_data": json.dumps(schema),
22              "enable_citations": "true"
23          }
24      )
25  response.raise_for_status()
26  job_id = response.json()["job_id"]
27  
28  for _ in range(60):
29      response = requests.get(
30          f"{BASE}/extract/{job_id}", headers=HEADERS)
31      response.raise_for_status()
32      job = response.json()
33      if job["status"] in ("completed", "review"): break
34      if job["status"] == "failed":
35          raise RuntimeError(job.get("error", "Extract failed"))
36      time.sleep(5)
37  else:
38      raise TimeoutError("Extract did not finish in 5 minutes")
39  
40  print(job["result"])
[ BUILT FOR PRODUCTION ]

The same API from
prototype to scale.

Use the same submit-and-poll workflow from prototype through production. Page-based pricing starts with a free tier, with managed, VPC, on-premises, and air-gapped deployment options for larger workloads.

Read the docs
99.9%

uptime target on enterprise plans.

SOC 2GDPRVPC availableOn-premises availableAir-gapped available
[ THE PLATFORM ]

One API for the document pipeline.

Extract uses the same authentication and billing as every other capability. Combine it with Parse, Extract, Split, and Classify, or call it on its own.

/parse

Parse

Turn documents into ordered Markdown and layout-aware JSON.

/split

Split

Split mixed files into labeled document and section ranges.

/classify

Classify

Classify PDFs before the rest of the pipeline runs.

[ FAQS ]

Extract
questions

Book a demo
  • Parse returns the full document as ordered Markdown and layout segments. Extract returns the fields defined in your JSON Schema, with a confidence score on each value and optional source citations.
  • Yes. The /v2/extract endpoint requires a valid JSON Schema with field types, properties, required fields, and any nested objects or arrays you need.
  • Yes. Define line items as an array of objects in the schema. Test long and irregular tables from your own workflow to establish appropriate validation and review rules.
  • Every field includes a confidence score. Enable citations to also receive page numbers and bounding boxes that point back to the source PDF.
  • Measure confidence on a representative validation set, then auto-accept values above your threshold and send the rest to review. Use stricter thresholds for high-risk fields such as totals, account numbers, and dates.
  • Pricing is based on pages processed, with a free tier and custom plans for higher-volume extraction and enterprise requirements.

See Unsiloed AI work on your own documents.

Tell us a little about your team, then pick a time. Bring a sample document and we’ll show you structured output on it during the call.

The accuracy, especially on tables, is meaningfully better than anything we tested. We evaluated over 15 solutions and Unsiloed was the only one that worked reliably.

Head of AI

Fortune 150 Bank, NY