Create Workflow

Create workflow

curl --request POST \
  --url https://api.anyformat.ai/v2/workflows/ \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "name": "<string>",
  "nodes": [
    {
      "id": "<string>",
      "type": "<string>",
      "mode": "standard",
      "prompt_hint": "<string>",
      "figure_enhancement": false,
      "cache": true,
      "effort": "mid",
      "ocr_effort": "high",
      "skip_routing_review": true,
      "figures": false,
      "text_formatting": false
    }
  ],
  "description": "",
  "edges": [
    {
      "source": "<string>",
      "target": "<string>",
      "branch": "<string>"
    }
  ]
}
'

import requests

url = "https://api.anyformat.ai/v2/workflows/"

payload = {
    "name": "<string>",
    "nodes": [
        {
            "id": "<string>",
            "type": "<string>",
            "mode": "standard",
            "prompt_hint": "<string>",
            "figure_enhancement": False,
            "cache": True,
            "effort": "mid",
            "ocr_effort": "high",
            "skip_routing_review": True,
            "figures": False,
            "text_formatting": False
        }
    ],
    "description": "",
    "edges": [
        {
            "source": "<string>",
            "target": "<string>",
            "branch": "<string>"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    name: '<string>',
    nodes: [
      {
        id: '<string>',
        type: '<string>',
        mode: 'standard',
        prompt_hint: '<string>',
        figure_enhancement: false,
        cache: true,
        effort: 'mid',
        ocr_effort: 'high',
        skip_routing_review: true,
        figures: false,
        text_formatting: false
      }
    ],
    description: '',
    edges: [{source: '<string>', target: '<string>', branch: '<string>'}]
  })
};

fetch('https://api.anyformat.ai/v2/workflows/', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.anyformat.ai/v2/workflows/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '<string>',
    'nodes' => [
        [
                'id' => '<string>',
                'type' => '<string>',
                'mode' => 'standard',
                'prompt_hint' => '<string>',
                'figure_enhancement' => false,
                'cache' => true,
                'effort' => 'mid',
                'ocr_effort' => 'high',
                'skip_routing_review' => true,
                'figures' => false,
                'text_formatting' => false
        ]
    ],
    'description' => '',
    'edges' => [
        [
                'source' => '<string>',
                'target' => '<string>',
                'branch' => '<string>'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.anyformat.ai/v2/workflows/"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.anyformat.ai/v2/workflows/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.anyformat.ai/v2/workflows/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "name": "<string>",
  "description": "A workflow for processing invoices and retrieving invoice details.",
  "created_at": "2023-11-07T05:31:56Z",
  "updated_at": "2023-11-07T05:31:56Z",
  "fields": [
    {}
  ]
}

{
  "error": "Authentication failed.",
  "detail": "Authentication failed.",
  "error_code": "AUTH_FAILED",
  "retryable": false,
  "request_id": "req_abc123"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

{
  "error": "Rate limit exceeded — retry after backoff.",
  "detail": "Rate limit exceeded — retry after backoff.",
  "error_code": "RATE_LIMITED",
  "retryable": true,
  "request_id": "req_abc123"
}

POST

workflows

Create workflow

curl --request POST \
  --url https://api.anyformat.ai/v2/workflows/ \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "name": "<string>",
  "nodes": [
    {
      "id": "<string>",
      "type": "<string>",
      "mode": "standard",
      "prompt_hint": "<string>",
      "figure_enhancement": false,
      "cache": true,
      "effort": "mid",
      "ocr_effort": "high",
      "skip_routing_review": true,
      "figures": false,
      "text_formatting": false
    }
  ],
  "description": "",
  "edges": [
    {
      "source": "<string>",
      "target": "<string>",
      "branch": "<string>"
    }
  ]
}
'

import requests

url = "https://api.anyformat.ai/v2/workflows/"

payload = {
    "name": "<string>",
    "nodes": [
        {
            "id": "<string>",
            "type": "<string>",
            "mode": "standard",
            "prompt_hint": "<string>",
            "figure_enhancement": False,
            "cache": True,
            "effort": "mid",
            "ocr_effort": "high",
            "skip_routing_review": True,
            "figures": False,
            "text_formatting": False
        }
    ],
    "description": "",
    "edges": [
        {
            "source": "<string>",
            "target": "<string>",
            "branch": "<string>"
        }
    ]
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    name: '<string>',
    nodes: [
      {
        id: '<string>',
        type: '<string>',
        mode: 'standard',
        prompt_hint: '<string>',
        figure_enhancement: false,
        cache: true,
        effort: 'mid',
        ocr_effort: 'high',
        skip_routing_review: true,
        figures: false,
        text_formatting: false
      }
    ],
    description: '',
    edges: [{source: '<string>', target: '<string>', branch: '<string>'}]
  })
};

fetch('https://api.anyformat.ai/v2/workflows/', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.anyformat.ai/v2/workflows/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '<string>',
    'nodes' => [
        [
                'id' => '<string>',
                'type' => '<string>',
                'mode' => 'standard',
                'prompt_hint' => '<string>',
                'figure_enhancement' => false,
                'cache' => true,
                'effort' => 'mid',
                'ocr_effort' => 'high',
                'skip_routing_review' => true,
                'figures' => false,
                'text_formatting' => false
        ]
    ],
    'description' => '',
    'edges' => [
        [
                'source' => '<string>',
                'target' => '<string>',
                'branch' => '<string>'
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.anyformat.ai/v2/workflows/"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.anyformat.ai/v2/workflows/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.anyformat.ai/v2/workflows/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"<string>\",\n  \"nodes\": [\n    {\n      \"id\": \"<string>\",\n      \"type\": \"<string>\",\n      \"mode\": \"standard\",\n      \"prompt_hint\": \"<string>\",\n      \"figure_enhancement\": false,\n      \"cache\": true,\n      \"effort\": \"mid\",\n      \"ocr_effort\": \"high\",\n      \"skip_routing_review\": true,\n      \"figures\": false,\n      \"text_formatting\": false\n    }\n  ],\n  \"description\": \"\",\n  \"edges\": [\n    {\n      \"source\": \"<string>\",\n      \"target\": \"<string>\",\n      \"branch\": \"<string>\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

{
  "id": "<string>",
  "name": "<string>",
  "description": "A workflow for processing invoices and retrieving invoice details.",
  "created_at": "2023-11-07T05:31:56Z",
  "updated_at": "2023-11-07T05:31:56Z",
  "fields": [
    {}
  ]
}

{
  "error": "Authentication failed.",
  "detail": "Authentication failed.",
  "error_code": "AUTH_FAILED",
  "retryable": false,
  "request_id": "req_abc123"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

{
  "error": "Rate limit exceeded — retry after backoff.",
  "detail": "Rate limit exceeded — retry after backoff.",
  "error_code": "RATE_LIMITED",
  "retryable": true,
  "request_id": "req_abc123"
}

We recommend creating workflows in the anyformat platform where you can visually configure fields, test with sample documents, and iterate faster. Once your workflow is ready, copy its ID and use it with the API to run workflows programmatically.

POST /v2/workflows/ creates a workflow from a strongly-typed graph. Use it to:

Configure parse-node settings (standard or agentic mode, prompt hints, figure enhancement)
Build parse-only workflows (no extract node — markdown only)
Route documents through classifiers or splitters to multiple extract nodes
Run simple linear parse → extract workflows

Request Body

Field	Type	Required	Description
`name`	string	Yes	Workflow name
`description`	string	No	Optional description
`nodes`	Node[]	Yes	At least one node; exactly one must be `type="parse"`
`edges`	Edge[]	No	Directed edges; empty for parse-only workflows

Parse Node

The entry-point node. Exactly one per workflow.

Field	Type	Default	Description
`id`	string	—	Stable identifier (e.g. `"parse_1"`)
`type`	`"parse"`	—	Discriminator
`mode`	`"standard" \| "agentic"`	`"standard"`	Use `"agentic"` for per-block LLM routing through typed strategies (text/table/figure)
`prompt_hint`	string	`null`	Domain hint shown to the parser (e.g. “medical lab report, preserve numerics exactly”)
`figure_enhancement`	boolean	`false`	Extract structured descriptions of charts and images (extra LLM cost)

Extract Node

Pulls structured fields from upstream parsed content.

Field	Type	Required	Description
`id`	string	Yes	Stable identifier
`type`	`"extract"`	Yes	Discriminator
`extraction_schema`	object	Yes	`{ "fields": [...] }` — at least one field
`use_images`	boolean	No (default `false`)	Pass rendered page images to the extraction model
`lookup_file_uploads`	object[]	No	Inline reference files for smart lookup, each `{ "filename": string, "content": "<base64>" }`
`lookup_files`	string[]	No	Reference files already stored as S3 URIs (alternative to `lookup_file_uploads`)
`lookup_suggestion`	string	No	Free-form hint telling the matcher how to join the document against the reference file

Field shape — see Field Types. Any field may set "source": "smart_lookup" to make it a smart-lookup field (resolved from a reference file rather than read from the document), or "source": "lookup_if_missing" to extract it too and let the lookup only fill empty slots; the default is "extraction".

Classify Node

Routes the document to one of categories[] based on an LLM verdict. Outgoing edges must set branch to a category id.

Field	Type	Required	Description
`id`	string	Yes	Stable identifier
`type`	`"classify"`	Yes	Discriminator
`categories`	Category[]	Yes	At least one category
`user_prompt`	string	No	Optional prompt prefix shown to the classifier

Each Category:

Field	Type	Required	Description
`id`	string	Yes	Stable category id; matched against an outgoing edge’s `branch` value
`name`	string	Yes	Display name shown to the LLM
`description`	string	Yes	Free-form description shown to the LLM

Splitter Node

Partitions a multi-document file into per-rule sub-documents. Each rule fires an outgoing edge whose branch matches the rule id; the downstream extract node runs once per resulting partition.

Field	Type	Required	Description
`id`	string	Yes	Stable identifier
`type`	`"splitter"`	Yes	Discriminator
`rules`	Rule[]	Yes	At least one rule

Each Rule:

Field	Type	Required	Description
`id`	string	Yes	Stable rule id; matched against an outgoing edge’s `branch` value
`name`	string	Yes	Display name
`description`	string	Yes	Free-form description shown to the splitter model
`partition_key`	string	No (default `""`)	Optional key used to label resulting partitions; empty means routing-only

Validate Node

Runs after an extract node and emits per-rule validation results. Rules are either AI-evaluated (kind="ai" with a natural-language description) or deterministic (kind="deterministic" with a structured check evaluated in pure Python, no model call).

Field	Type	Required	Description
`id`	string	Yes	Stable identifier
`type`	`"validate"`	Yes	Discriminator
`rules`	Rule[]	Yes	At least one rule

Each Rule:

Field	Type	Required	Description
`id`	string	Yes	Stable rule id; round-trips through `ValidationResult.rule_id`
`kind`	`"ai" \| "deterministic"`	No (default `"ai"`)	Evaluation strategy
`name`	string	No	Optional display name for the rule card
`description`	string	Conditional	Natural-language prompt; required when `kind="ai"`, forbidden when `kind="deterministic"`
`check`	Check	Conditional	Structured deterministic check; required when `kind="deterministic"`, forbidden when `kind="ai"`
`severity`	`"error" \| "warning"`	No (default `"error"`)	Severity of a violation
`source_fields`	string[]	No	`persistent_id`s of fields the rule references

Deterministic check shapes (discriminated on type). Every shape below except expression names its field operands by persistent_id; expression addresses fields by extracted name instead.

`type`	Required fields	Optional fields	Meaning
`range`	`field`	`min`, `max` (at least one)	Numeric `field` is within `[min, max]`
`date`	`field`	`earliest`, `latest` (ISO `YYYY-MM-DD` or the literal `"today"`)	Date `field` is within the inclusive bounds
`arithmetic`	`operands[]` (at least one item), `equals`	`operator` (`"sum" \| "subtract" \| "product"`, default `"sum"`), `tolerance` (default `0.0`)	`operator(operands)` equals the value of the `equals` field, within `tolerance`
`comparison`	`left`, `op`, `right`	—	`left <op> right` holds. `op`: `"==" \| "!=" \| ">" \| ">=" \| "<" \| "<="`. `right` is `{"source": "field", "field": "<pid>"}` or `{"source": "literal", "value": <number\|string\|bool>}`
`one_of`	`field`, `allowed[]` (at least one item)	`case_sensitive` (default `false`)	`field`’s value is one of `allowed`
`regex`	`field`, `pattern`	—	`field` matches `pattern`. Evaluated with google-re2 (linear time); stdlib `re` syntax that isn’t re2-safe is rejected
`required`	`field`	—	`field` is present (non-null, non-empty)
`expression`	`expression` (1–1000 chars)	—	A CEL expression over the whole extraction, bound to one root variable `data`. Fields are addressed by extracted name (`data.total`, `data.lineas.map(l, l.importe)`). Helpers on top of CEL: `num(v)`, `sum(list)`, `abs(x)`. Anything the evaluator cannot answer with a boolean is `inconclusive`

Example — arithmetic check (subtotal + tax == total, ±1¢):

{
  "id": "totals_balance",
  "kind": "deterministic",
  "check": {
    "type": "arithmetic",
    "operator": "sum",
    "operands": ["pid_subtotal", "pid_tax"],
    "equals": "pid_total",
    "tolerance": 0.01
  },
  "source_fields": ["pid_subtotal", "pid_tax", "pid_total"]
}

Edges

Field	Type	Required	Description
`source`	string	Yes	Source node id
`target`	string	Yes	Target node id
`branch`	string	Conditional	Required when leaving a `classify` or `splitter` node; forbidden otherwise. Must equal a category/rule `.id` on the source node — not its `.name`. Using `.name` is rejected with `400`.

Examples

Linear parse → extract

curl -X POST 'https://api.anyformat.ai/v2/workflows/' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "name": "Invoice extractor",
    "nodes": [
      {"id": "parse_1", "type": "parse"},
      {
        "id": "extract_1",
        "type": "extract",
        "extraction_schema": {
          "fields": [
            {"name": "invoice_number", "description": "Invoice ID", "data_type": "string"},
            {"name": "total", "description": "Grand total", "data_type": "float"}
          ]
        }
      }
    ],
    "edges": [{"source": "parse_1", "target": "extract_1"}]
  }'

import requests

response = requests.post(
    "https://api.anyformat.ai/v2/workflows/",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "name": "Invoice extractor",
        "nodes": [
            {"id": "parse_1", "type": "parse"},
            {
                "id": "extract_1",
                "type": "extract",
                "extraction_schema": {
                    "fields": [
                        {"name": "invoice_number", "description": "Invoice ID", "data_type": "string"},
                        {"name": "total", "description": "Grand total", "data_type": "float"},
                    ]
                },
            },
        ],
        "edges": [{"source": "parse_1", "target": "extract_1"}],
    },
)
workflow_id = response.json()["id"]

Parse-only with agentic mode

A workflow with just one parse node and no edges. Produces markdown only — no extraction.

curl -X POST 'https://api.anyformat.ai/v2/workflows/' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "name": "Agentic parse-only",
    "nodes": [
      {
        "id": "parse_1",
        "type": "parse",
        "mode": "agentic"
      }
    ],
    "edges": []
  }'

import requests

response = requests.post(
    "https://api.anyformat.ai/v2/workflows/",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "name": "Agentic parse-only",
        "nodes": [
            {
                "id": "parse_1",
                "type": "parse",
                "mode": "agentic",
            }
        ],
        "edges": [],
    },
)
workflow_id = response.json()["id"]

Agentic mode routes each block through a typed strategy (text / table / figure) using Gemini for routing. The mode is binary — set mode: "agentic" and you get the full agentic pipeline. See the Agentic Parse to Markdown recipe for an end-to-end walkthrough.

Classify-then-extract (branched)

Each outgoing edge from a classify (or splitter) sets branch to a category/rule .id on the source node. .name is the display label shown to the LLM and is not accepted as a branch value — using it returns 400. In the example below, cat_invoice is the id used for routing; Invoice is the label the classifier sees.

curl -X POST 'https://api.anyformat.ai/v2/workflows/' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "name": "Multi-doc",
    "nodes": [
      {"id": "parse_1", "type": "parse"},
      {
        "id": "classify_1",
        "type": "classify",
        "categories": [
          {"id": "cat_invoice", "name": "Invoice", "description": "Vendor invoice."},
          {"id": "cat_receipt", "name": "Receipt", "description": "POS receipt."}
        ]
      },
      {
        "id": "extract_invoice",
        "type": "extract",
        "extraction_schema": {"fields": [{"name": "vendor", "description": "Vendor name.", "data_type": "string"}]}
      },
      {
        "id": "extract_receipt",
        "type": "extract",
        "extraction_schema": {"fields": [{"name": "merchant", "description": "Merchant name.", "data_type": "string"}]}
      }
    ],
    "edges": [
      {"source": "parse_1", "target": "classify_1"},
      {"source": "classify_1", "target": "extract_invoice", "branch": "cat_invoice"},
      {"source": "classify_1", "target": "extract_receipt", "branch": "cat_receipt"}
    ]
  }'

Smart lookup

Enrich extracted values by matching them against a reference file instead of reading them off the page. Flag the looked-up field with "source": "smart_lookup", attach the reference file (inline as base64 via lookup_file_uploads, or by S3 URI via lookup_files), and optionally describe the join with lookup_suggestion. See Smart Lookup for how matching works and the Studio UI equivalent of these fields. Here the model reads vendor_name from the document, then resolves the canonical vendor_id from a vendor catalog:

curl -X POST 'https://api.anyformat.ai/v2/workflows/' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -d '{
    "name": "Invoice + vendor lookup",
    "nodes": [
      {"id": "parse_1", "type": "parse"},
      {
        "id": "extract_1",
        "type": "extract",
        "lookup_file_uploads": [
          {"filename": "vendor_catalog.csv", "content": "dmVuZG9yX25hbWUsdmVuZG9yX2lkCkFjbWUgQ29ycCxWLTAwMDEK"}
        ],
        "lookup_suggestion": "Match the extracted vendor_name against the vendor_name column and return the matching vendor_id.",
        "extraction_schema": {
          "fields": [
            {"name": "vendor_name", "description": "Vendor as printed on the document", "data_type": "string"},
            {"name": "total", "description": "Grand total", "data_type": "float"},
            {"name": "vendor_id", "description": "Canonical vendor code from the catalog, joined on vendor_name", "data_type": "string", "source": "smart_lookup"}
          ]
        }
      }
    ],
    "edges": [{"source": "parse_1", "target": "extract_1"}]
  }'

lookup_file_uploads[].content is the base64-encoded bytes of the reference file (CSV/text). The lookup field (vendor_id) is returned alongside the extraction fields in the results payload — there is no separate response section for it. An extract node that has a source: smart_lookup/lookup_if_missing field but no reference file is rejected with 400.

Topology Rules

The endpoint enforces graph correctness — if any rule is violated, the request returns 400 and nothing is persisted.

Rule	Message
Exactly one parse node	`workflow must contain exactly one \`parse` node`
Unique node ids	`duplicate node ids: [...]`
Edges reference existing nodes	`edge source X not in nodes` / `edge target Y not in nodes`
Edge predecessor compatibility	`extract does not accept extract as predecessor`
Branch routing	`edge from classify X requires \`branch` to be set`
Branch matches source `.id`	`edge from classify 'classify_1' sets branch='Invoice', but no category on 'classify_1' has that id (valid ids: ['cat_invoice']). \`branch` must match a category `.id`, not its `.name`.`
No fan-out from non-routers	`node Y (extract) has 3 outgoing edges; only classify and splitter may fan out`

Response

201 Created returns the workflow resource:

{
  "id": "0686bb97-8c30-70f0-8000-97669e000eb8",
  "name": "Invoice extractor",
  "description": "",
  "created_at": "2026-05-11T10:00:00Z",
  "updated_at": "2026-05-11T10:00:00Z"
}

Save the id — you’ll reuse it when uploading documents and fetching results.

Next Steps

Agentic Parse to Markdown

End-to-end recipe: create → upload → results, with the new agentic parse mode

Parse-Only Workflow

Convert documents to markdown without extraction

Field Types

All supported data_type values for extraction fields

Response Formats

The shape of parse, extractions, splits, and classifications on the results endpoint

Authorizations

Authorization

string

header

required

API key issued from app.anyformat.ai/api-key. Send as Authorization: Bearer <key>.

Body

application/json

Public-surface workflow create body — typed graph of parse / classify / splitter / extract / validate nodes.

A validate node carries rules; each rule is either AI-evaluated (kind="ai" + a natural-language description) or deterministic (kind="deterministic" + a structured check, evaluated in pure Python with no model call).

Uses PublicNode (public request models with only the fields callers may set); the domain AnyNode also carries filter (worker-only) and executor-injected / staff-only fields, so the public bodies pin a stricter node schema. Call :meth:to_domain before validating topology or forwarding to the backend.

name

string

required

Minimum string length: 1

Example:

"Invoice or receipt"

nodes

required

Minimum array length: 1

Show child attributes

description

string | null

default:""

edges

Edge · object[]

Show child attributes

Response

Successful Response

A workflow defines the extraction template — what fields to extract from documents, their types, and validation rules.

string

required

Unique identifier of the workflow (UUID).

Example:

"0686bb97-8c30-70f0-8000-97669e000eb8"

name

string

required

Human-readable name of the workflow.

Example:

"Invoice Processing"

description

string | null

Optional description of what this workflow extracts.

Example:

"A workflow for processing invoices and retrieving invoice details."

created_at

string<date-time> | null

Timestamp when the workflow was created (ISO 8601).

updated_at

string<date-time> | null

Timestamp when the workflow was last modified (ISO 8601).

fields

Fields · object[] | null

List of extraction field definitions configured for this workflow. null if not yet configured.

Overview

SDKs

Workflows

Files

Webhooks

Request Body

Parse Node

Extract Node

Classify Node

Splitter Node

Validate Node

Edges

Examples

Linear parse → extract

Parse-only with agentic mode

Classify-then-extract (branched)

Smart lookup

Topology Rules

Response

Next Steps

Agentic Parse to Markdown

Parse-Only Workflow

Field Types

Response Formats

Authorizations

Body

Response

​Request Body

​Parse Node

​Extract Node

​Classify Node

​Splitter Node

​Validate Node

​Edges

​Examples

​Linear parse → extract

​Parse-only with agentic mode

​Classify-then-extract (branched)

​Smart lookup

​Topology Rules

​Response

​Next Steps

Agentic Parse to Markdown

Parse-Only Workflow

Field Types

Response Formats

Authorizations

Body

Response

Request Body

Parse Node

Extract Node

Classify Node

Splitter Node

Validate Node

Edges

Examples

Linear parse → extract

Parse-only with agentic mode

Classify-then-extract (branched)

Smart lookup

Topology Rules

Response

Next Steps