Platform Flow

The Talonic platform flow takes a document from upload to delivered structured data in seven stages: upload, extraction, knowledge graph building, schema definition, pipeline run, review, and delivery. The stages group into three movements: ingest (upload and extraction on the Documents page), structure (the registry, the Spec and its Pipelines), and review (Products, Review Mode and delivery). Each stage produces outputs that feed the next, and results appear progressively as each phase completes rather than at the end of the run.

1. Upload — Drag files or folders onto the Documents page, or ingest through a connected source. 25+ formats supported. ZIP archives are unpacked automatically.
2. Extract — Each document is processed through Document AI (OCR + annotation), classified against the document type ontology, and sent to AI for exhaustive field extraction.
3. Graph builds — Extracted fields resolve into the Field Registry — canonical names, clusters, master instructions.
4. Define schema — Create a template with the fields you need. Map to registry, add reference tables.
5. Run — Open the Spec (/specs) and run or preview it: this compiles a Pipeline shown in Pipelines (/pipelines) that fills every cell. For a quick one-off, use Extract (Cmd+J). ~30% from graph matches (instant), ~70% from AI extraction.
6. Review & approve — Open Products, pick a data product whose Status needs review, and work it in Review Mode with confidence indicators, provenance, and validation flags. Approve or correct values; every decision lands in the Decision log.
7. Deliver — Push approved data to webhooks, REST APIs, SFTP, email, or cloud storage.

Quick Jobs are designed to be progressive: results appear as each Job phase completes rather than waiting for the entire run to finish. Phase 1 (graph resolve) fills ~30% of cells instantly and for free. Phase 2 (the Planner) fills the remaining gaps. Phases 3 and 4 handle re-resolution and transformation. You can start reviewing early results while later phases are still running.

The Run stage has two modes. A Job is the quick one-time path: pick a schema and documents and run them immediately, ideal for ad-hoc work. A Spec is the production path: a reusable configuration over one schema with a composed rail, Data Policies, validation checkpoints, and an assembly rule. Running a Spec executes a Pipeline on the engine, and fields that fail a blocking checkpoint are held for review on Products before they ship. After all documents finish, an optional assembly step folds related documents into a single composed record. Set a Spec up once and every later run is a single call.

Use the platform flow as a mental model when planning your workflow. For small, ad-hoc runs you can go from upload to results in minutes — upload a few documents, pick an auto-generated schema, and run a job. For production workloads, invest time in the Define schema step: map fields to the registry, add reference tables for code lookups, and set format constraints. The upfront effort pays off because every subsequent job reuses the same schema and benefits from the growing knowledge graph.

After results are delivered, the feedback loop closes automatically. Corrections you make during the Review stage feed back into the Field Registry, improving future extractions. The platform tracks telemetry across runs — strategy distribution, capture hit rate, and resolve rate — so you can monitor how extraction quality improves over time as the knowledge graph accumulates more data.

Each stage of the pipeline is observable through both the web interface and the API. The Dashboard provides a visual overview of pipeline progress across the flow stages, while the telemetry API exposes the same metrics programmatically. For production deployments, teams often integrate these telemetry endpoints with external monitoring tools like Grafana or Datadog to maintain continuous visibility into pipeline health, extraction quality trends, and processing throughput.

Automating the Flow via API

The entire platform flow can be automated through the REST API. Upload documents to a source, wait for extraction to complete (or receive a webhook notification), then run a Spec as a Pipeline (POST /v1/pipelines) or create a quick Job against a schema (POST /v1/jobs). The API follows the same flow stages as the web interface: the only difference is that each step is triggered programmatically instead of through the UI. This makes it straightforward to embed Talonic into existing data pipelines or orchestration tools.

curl -X POST https://api.talonic.com/v1/jobs \
  -H "Authorization: Bearer $TALONIC_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "schema_id": "sch_inv_001",
    "document_ids": ["doc_7f3a1b2c", "doc_9e4d5f6a"]
  }'

{
  "id": "job_x8k2m9",
  "status": "pending",
  "message": "Job created and queued for processing.",
  "links": {
    "self": "/v1/jobs/job_x8k2m9",
    "results": "/v1/jobs/job_x8k2m9/results"
  }
}

For production deployments, combine source connectors with routing rules and delivery bindings to create a fully hands-off pipeline. Documents arrive from Google Drive or S3, routing rules assign the correct schema and trigger extraction, and delivery bindings push approved results to your webhook endpoint or cloud storage. The platform handles retries, deduplication, and error escalation automatically, so you only need to intervene when the dead-letter queue flags a terminal failure.