sh.stipple/openwarrant

Tools

• check_document

  Cheap cache-check: has this exact document already been inspected? Hash the file yourself (sha256, lowercase hex) and call this before verify_document to skip a redundant (paid) inspection. Returns {cached, warrant_id, permalink}. Free — costs 0 credits.

  shallow
• check_pack

  Check whether a SET of documents satisfies a checklist — completeness, cheaply. USE THIS WHEN you have an application / onboarding pack and need "do we have the required documents, and what's still missing?" Each document is CLASSIFIED (one cheap page-1 read — never full field extraction or multi-page), then matched against the checklist's required slots. (For "is a document genuine?" use verify_document; to identify ONE document use extract_fields with options={"classify": true}; for the identity gate use verify_identity.) Define the checklist ONE of two ways: - `scheme`: a named preset — "income_proof", "lending_prequal", "rental_application". - `requirements`: an ad-hoc checklist — a list of document-type names like ["payslip","bank_statement"], or objects {"key":..., "accepts":[types], "optional":bool}. `documents` is a list (up to 12), each ONE of: {"url": "https://..."} (public link, fetched server-side) or {"bytes_b64": "...", "filename": "statement.pdf"} (inline). Returns `{complete, slots[] (key, satisfied, matched), missing[], documents[] (filename, classified_type), unmatched_documents[]}`. COVERAGE, not approval — that the right document TYPES are present, NOT that any is genuine (run verify_document) or that an application is approved. Documents are never stored. Costs 3 credit(s) per call.

  shallow
• detect_ai_text

  Estimate the PROBABILITY that a document's text was AI-GENERATED (LLM-written prose). USE THIS WHEN someone shares prose — an essay, cover letter, article, review, application, or report (or a link to one) — and asks: did an AI / ChatGPT write this? is this human-written? detect AI text. Provide the document ONE way: `text` (pasted markdown/plain prose), `url` (a public http(s) link to a page or PDF — fetched server-side, the cheapest call), OR `bytes_b64` (a base64 PDF/file, plus `filename` for routing). Returns `{probability, lean, tells, reasoning, applicable}`. HONEST SCOPE: the probability is the model's CONFIDENCE, not a calibrated truth — it can false-flag templated/coached or non-native-English writing. It works on PROSE only: for a form/table/numeric document (payslip, statement) it returns `applicable: false` and abstains, because AI-text detection false-positives badly there — use `verify_document` (the authenticity engine) for those, and `verify_references` to check a doc's citations/claims. Costs 1 credit(s) per call.

  shallow
• extract_fields

  Extract structured FIELDS from a document (PDF or image) with a vision model. USE THIS WHEN you need specific values OUT of a document — a payslip's gross/net, an invoice's total/ABN, a form's checkboxes, a table's cells — rather than a yes/no about the document. (For "is this genuine?" use verify_document; "what kind of document is this?" is `options={"classify": true}` right here.) Say WHAT to pull, four ways: - `fields`: an ad-hoc list — names like ["gross_pay","abn"], or objects {"name":..., "type":"text|amount|date|boolean", "description":...}. THE general case: ask for exactly the fields your task needs. Use type "boolean" for a checkbox/tickbox. `"question"` works instead of `"description"` if you would rather just ask: {"name":"customer_name", "question":"What is the customer name?"}. - `template`: a named preset — "payslip", "tax_invoice", "bank_statement", "receipt". - NEITHER: AUTO — the document is classified and that type's fields are used. - auto on an unrecognised type: schema-free — every labelled field is returned. Provide the document ONE way: `url` (a public http(s) link — fetched server-side, the cheapest call) OR `bytes_b64` (inline base64, plus `filename` for PDF-vs-image routing). `country` is an optional hint; `max_pages` caps how many pages are read (default a few; hard ceiling 10). `options` turns on extra capabilities. Every one defaults OFF, and asking for one that this server does not support is an ERROR naming it — never a silent no-op, so you can always tell "asked wrongly" from "nothing found". Available today: - `{"grounding": true}` — every value gains `bbox` (the rectangle it was read from, in PDF points, origin top-left) and `text_layer_match`. Use it to CITE a value back to the page. Born-digital PDFs only for now; a scan returns `bbox: null` and `grounding: "none"`. - `{"flag_below": 0.7}` — adds `needs_review`, the fields under that confidence, weakest first. Use it to route the doubtful ones to a human instead of checking everything. - `{"tables": true}` — adds `tables`: whole tables with their rows. On a PDF these are read from the document's own rules and coordinates (exact cells, merged-cell colspans, no model call and NO CREDIT for the table pass); on a scan the model reads the rows and the table says `source: "vlm"` with no cell geometry. `{"tables": {"formats": ["json","markdown","html"], "borderless": true, "cells": true}}` to tune it. - `{"classify": true}` — adds `classification`: the full verdict (type, country, confidence, evidence), not just the routing. Free in auto mode. - `{"redact": true}` — adds `pii` (a MASKED inventory) and `redacted_text`, so you can extract and check for personal data in ONE call. A field you NAMED is still returned in full; the inventory never is. Two things to know before turning it on: `redacted_text` is the document's WHOLE text body with detected PII replaced — for a PDF that means every page, not just the ones `max_pages` covers — and redaction is best-effort coverage, so anything it failed to detect stays in that text verbatim. It also costs an extra page-equivalent per page, because it is a second model pass. - `{"layout": true}` — adds `layout.blocks`: every text block with its role (heading/body), font, size, column and reading order. Born-digital PDFs only; free. - `{"links": true}` — adds `links`: the PDF's own link annotations with uri, anchor text and bbox. Free. A URL merely PRINTED on the page is not an annotation. - `{"figures": true}` — adds `figures`: where the embedded images sit (bbox and pixel size), never the bytes. Free. - `{"chunks": true}` — adds `chunks`: retrieval-ready pieces that carry provenance a text splitter cannot give you — `heading_path` (where in the document), `bbox` and page range (citable back to the page), tables never sliced. Six strategies via `{"chunks": {"strategy": "section|page|chars|recursive|element|hierarchical", "max_chars": 1500, "min_chars": 200, "overlap": 100, "include_headings": true}}`. `hierarchical` adds parent context chunks for small-to-big retrieval. Born-digital PDFs only; free. - `{"split": true}` — adds `documents`: the page ranges of the distinct documents in one file (a bundle of 3 stapled PDFs -> 3 entries with types). One classifier call per page, so it costs +1 page-equivalent per page read. `render_scale` (one of 1.0, 1.5, 2.0, 3.0, 4.0; default 2.0) raises rasterisation for small or dense print. Call `GET /v1/extract/capabilities` for the full machine-readable list. COST: 1 credit per page read, minimum 1 — with `fields` or a `template` given, a one-page receipt costs 1 and a ten-page statement costs 10; AUTO mode adds 1 for the routing classification. Options that add model reads add page-equivalents (`redact` +pages, `split` +pages replacing the auto/classify +1, `tables` +pages only on a scan); deterministic work is free, and an encrypted PDF is charged the one-page floor only. Pages charged is min(`max_pages`, the document's real length), resolved before the call runs, so you can predict the price. Set `max_pages` to cap your spend on a long document. CAPABILITY-ONLY: `options.classify` and/or `options.redact` with no `fields`, no `template` and no other option skips field extraction entirely — classify-only costs 1 credit and redact-only 1 per page, exactly what the retired classify_document and redact_pii tools charged. Returns `{mode, document_type, fields{name:{value,confidence,page}}, not_found, pages_read, page_limit, page_count}`. `page_count` is the document's real length, so you can see when `max_pages` truncated it. EXTRACTION, not verification — values are what the document SHOWS, not proof it is genuine. A field that isn't clearly present comes back in `not_found` (it abstains rather than guessing). `text_layer_match` is `exact` / `normalised` when the printed value was located on the page, `multiple` when the same string appears more than once (no box — we will not guess which), and `absent` when it is not there. It reports whether the string was FOUND, not that the value is correct. The document is never stored. Costs 1 credit(s) PER PAGE read (minimum 1) — cap a long document with max_pages.

  shallow
• get_warrant

  Retrieve a stored warrant by id (e.g. 'warrant_<hex>') — the full bundle as JSON, or a human-readable Markdown report when as_markdown=True. USE THIS WHEN you have a warrant_id from an earlier verify_document / check_document call and need the FULL evidence — every signal that fired, per-page findings, provenance — rather than the summary the original call returned. Use as_markdown=True to get a report you can show a human verbatim. Free — costs 0 credits.

  shallow
• screen_adverse_media

  Screen a person or organisation for ADVERSE MEDIA and SANCTIONS/PEP exposure (KYC/AML). USE THIS WHEN onboarding or due-diligence asks: does this subject appear in negative news (fraud, money laundering, bribery, sanctions, trafficking, enforcement action), or on a sanctions / politically-exposed-person list? Pairs naturally after verify_identity. Identify the subject ONE of two ways: pass `name` (plus any of `dob` as YYYY-MM-DD, `country`, `aliases`, `employer`, `role` — these sharpen matching and cut same-name false positives), OR pass an identity document via `url`/`bytes_b64` (+`filename`) and the subject is read from it. Returns `{subject, sanctions{...}, adverse_media{...}, risk_flag, headline, limitations}`: sanctions candidates are corroboration-gated (a name-only hit is `possible`, NEVER confirmed — one common name matches several different people); media hits are entity-disambiguated and classified, with same-name articles surfaced under `excluded`. This is screening COVERAGE, not a determination — a hit means "review this", not "guilty"; "nothing found" is not a clean record. Stateless — nothing is stored. Costs 3 credit(s) per call.

  shallow
• submit_feedback

  Record thumbs up/down on a warrant's rating (the engine's precision-flywheel label source). verdict must be 'up' or 'down'; note is optional free text. USE THIS WHEN the ground truth became known after a verify_document call — e.g. the document was later confirmed genuine or fraudulent — so the engine learns from the outcome. Tell it what happened; it sharpens future inspections for everyone. Free — costs 0 credits.

  shallow
• verify_document

  Forensically inspect a document (PDF or image) for authenticity: tampering signs, AI-generation indicators, arithmetic reconciliation (financial docs), and provenance. USE THIS WHEN someone shares a payslip, bank statement, invoice, receipt, ID, certificate, or contract and asks: is this genuine / real / authentic? has it been edited, doctored, or photoshopped? can I trust this file? (For "did an AI *write* this prose" use detect_ai_text on /mcp-aitext; for "are this report's citations real" use verify_references on /mcp-verify.) Provide the document ONE way: `url` (a public http(s) link — fetched server-side, the cheapest call: no need to download or encode anything) OR `bytes_b64` (inline base64, plus `filename` so PDF-vs-image routing is right). Returns the headline result — `risk_band` (low/medium/high/insufficient/error), `inspection_quality` (coverage, orthogonal to risk), `recommended_action`, a `summary`, the RISK-axis `risk_findings`, and a shareable `permalink`. This is a SIGNAL, not a fraud verdict — a human or agent adjudicates. Use `get_warrant(warrant_id)` for the full evidence bundle. Identical bytes are cached by content hash — `check_document` first skips a redundant, paid inspection. Costs 2 credit(s) per call (10 in deep mode).

  shallow
• verify_identity

  Run an Australian identity check over a SET of identity documents. A vision model reads each document (which ID it is, which fields it shows — name/photo/address/signature — and its issue date); a deterministic engine then tallies them against a scheme and reports whether identity is established, and exactly what's still missing if not. USE THIS WHEN someone needs to verify a person's identity from their documents — KYC / onboarding / "do these documents satisfy the 100-point check?" Pass ALL the person's documents together (a passport alone is 70 points; the check needs >= 100). `documents` is a list, each item ONE of: {"url": "https://..."} (public link, fetched server-side) or {"bytes_b64": "...", "filename": "passport.pdf"} (inline). Up to 10. `scheme`: "afp_100_point" (points, default) or "austrac_safe_harbour" (category combinations). Returns `{established, points/target or satisfied_path, documents[] (per-document: type, fields shown, whether it counted and why-not), reason, accepts, ...}`. This is identity COVERAGE, not a forgery judgment — run verify_document for authenticity. Documents are never stored. Costs 2 credit(s) per call.

  shallow
• verify_references

  Fact-check a document's REFERENCES and CLAIMS — built for AI-generated reports whose citations must be checked before they're trusted. USE THIS WHEN someone shares a report, article, whitepaper, or deep-research export (or a link to one) and asks: is this accurate / legit? are these citations real? fact-check this. did the AI make this up? Also use it proactively before relying on any AI-written document. Provide the document ONE way: `url` (a public http(s) link to a PDF or web page — fetched server-side, the cheapest call: no need to download or encode anything), `text` (pasted markdown/plain prose), OR `bytes_b64` (a base64 PDF; URLs are read from the PDF's link annotations, so they're exact). Default (fast): provenance (is it a ChatGPT deep-research export?), citation resolution (live / archived / dead, papers matched against arXiv/Crossref to catch 'real ID, wrong paper'), and internal MATH (recompute the doc's own arithmetic). Set `deep=true` to also fetch each cited source and judge whether it SUPPORTS or CONTRADICTS the claim (slower, ~a minute). Returns a trust summary, per-item tables, and a shareable `permalink` to the public fact-check record. HONEST BOUNDARY: this reports verification COVERAGE, not truth — 'supported' means evidence-backed (not necessarily true) and 'unsupported' means no evidence found (not necessarily false). It tells a reviewer WHERE to look; it does not bless the document, and it never affects the fraud risk band. Costs 2 credit(s) per call (5 in deep mode).

  shallow

Embed this server’s score

Tool count and median score across every tool in this server’s corpus — honest in a way a single cherry-picked tool’s badge wouldn’t be.

[![Vouch score](https://vouch.tools/api/servers/8c294c68-8070-4f87-9cd6-451c68a5e2d3/badge.svg)](https://vouch.tools/servers/8c294c68-8070-4f87-9cd6-451c68a5e2d3)