ForHosting KIT · OCR & Data Extraction

Read a purchase order

A purchase order is a promise written in a document, and until someone types its line items into a system that promise can't be checked against what actually ships. This endpoint reads a PO — from a buyer's own template or a customer's — and returns items, quantities, unit prices and delivery terms as structured JSON.

● BetaPer request + per page$0.010

Run — $0.010 + $0.0575/page How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Why purchase orders pile up unread by machines

A supplier fulfilling orders from dozens of customers receives POs in as many formats as it has customers — each buyer's procurement system exports its own layout, its own numbering scheme, its own way of expressing a delivery date. The order itself is simple: what, how many, by when, at what price. Getting that out of an inconsistent document at volume is the actual work, and it's exactly the kind of repetitive, format-agnostic reading that doesn't need a person doing it.

Who reads POs for a living

Sales operations teams entering incoming customer orders into an order-management system, suppliers confirming a PO against available inventory before accepting it, procurement platforms that need to normalize orders from many buyer formats into one internal schema, and small manufacturers still receiving purchase orders by fax or email PDF rather than EDI. Distributors juggling both retail and wholesale buyers see the widest variety of formats, since each channel tends to bring its own ordering conventions.

What comes out the other side

Submit the PO, get a task_id right away, and the finished job returns PO number and date, buyer and vendor details, requested items with quantity and unit price, delivery date and any stated terms — as clean JSON fields ready to check against inventory or push into an order system, not a page of text to re-read.

How it plugs into order-to-cash

Since the call is asynchronous and priced per page, a one-page PO for a single item costs the same regardless of how it's formatted, while a long multi-line order scales proportionally: an order-intake pipeline watches an inbox or upload folder, submits each incoming PO the moment it arrives, and the webhook triggers inventory allocation the instant structured data is ready.

A document older than the software reading it

The purchase order predates computers by centuries — it's a formalization of a simple commercial promise that businesses have exchanged on paper since long before EDI or ERP systems existed. What's changed is the volume: a modern supplier handling this at scale needs the same information a clerk once copied by hand, just fast enough to keep up with hundreds of orders a day.

What you can do with it

Order-intake automation

Sales operations feeds incoming customer POs into the API and pushes the parsed line items straight into the order-management system.

Inventory allocation checks

A supplier automatically checks parsed PO quantities against available stock before confirming or backordering the order.

Multi-buyer normalization

A B2B platform ingests purchase orders from many customer procurement systems and normalizes them into one internal schema.

Fax and email PO handling

A small manufacturer still receiving orders by fax or PDF email converts each one to structured data without manual re-keying.

FAQ

How do I use the Purchase Order Parser API?

Send the PO file to POST /ocr/purchase-order, receive a task_id immediately, and get structured JSON back by webhook or a signed link when it's ready.

Does it offer a free trial?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

What's the price?

$0.010 per request plus $0.0575 per page, published and flat, so cost scales with document length, not with how many items are on it.

Can it handle any PO template?

It's built to read purchase order structure generally rather than a single fixed layout, so it adapts across buyer formats without per-customer setup.

What formats can I submit?

PDF purchase orders and clear image scans, including scanned faxes, work well; a legible source gives the most complete result.

Does it detect delivery dates and terms?

Yes, when stated on the document it extracts requested delivery date and any listed terms alongside the line items.

Can I submit a batch of POs at once?

Each request handles one purchase order and returns its own task_id, so a batch is just parallel requests collected by webhook.

Am I charged if parsing fails?

No. A failed task retries automatically up to three times and is never charged; you receive a clear error instead.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/ocr/purchase-order

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/ocr/purchase-order \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/ocr/purchase-order", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/ocr/purchase-order",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/purchase-order", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/purchase-order", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "ocr.purchase_order",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.010

Per page$0.0575

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	10

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`413`	`input_too_large`	The file exceeds the size limit.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →