Discovering document types

Read the registry at build time instead of hardcoding type names.

Goal. Fetch the list of document types and accepted file formats programmatically, so your integration does not carry a hardcoded copy that silently goes stale.

New document types are added as configuration rather than as a release. A list you hardcode today will be incomplete at some point, and you will not get an error when it happens — you will get a rejected or badly-routed document.

Before you start

Nothing. The main endpoint here is the one operation on the API that needs no key.

Step 1 — List the document types

Use List supported documents for the complete response schema.

curl -s "https://api-docai-uat.uptiq.ai/listSupportedDocuments"

{
  "status": "success",
  "documents": [
    {
      "type": "BalanceSheet",
      "name": "Balance Sheet",
      "category": "Financial Report",
      "description": "Statement of assets, liabilities and equity at a point in time"
    }
  ],
  "taxForms": {
    "Business": [ ],
    "BusinessTaxForms": [ ],
    "IndividualTaxForms": [ ]
  }
}

Field	Use
type	The value you send as documentType. This is the one that matters
name	Human-readable label, for your own UI
category	Grouping — useful for building a picker or routing by family
description	What the type covers, for disambiguation

taxForms is a separate object, not part of documents, and it is keyed by group (Business, BusinessTaxForms, IndividualTaxForms) rather than being a flat list. Code that reads only documents will miss every tax form. Handle both.

Step 2 — Build a lookup

curl -s "https://api-docai-uat.uptiq.ai/listSupportedDocuments" \
  | jq -r '.documents[] | "\(.category)\t\(.type)\t\(.name)"' \
  | sort > document-types.tsv

Or as a validation set:

import json, urllib.request

with urllib.request.urlopen("https://api-docai-uat.uptiq.ai/listSupportedDocuments") as r:
    registry = json.load(r)

valid = {d["type"] for d in registry["documents"]}
for group in registry.get("taxForms", {}).values():
    valid.update(group if isinstance(group, list) else group.keys())

def check(document_type):
    if document_type not in valid:
        raise ValueError(f"{document_type!r} is not a supported document type")

Refresh it as part of your build, and fail the build when a type you depend on disappears. That turns a silent runtime misroute into a visible build failure.

Step 3 — Check accepted file formats

Formats vary by document type — a bank statement accepts spreadsheets, an ID document does not. This endpoint does require a key, despite sitting in the same group as the public one.

Use Get supported file types for the complete response schema.

curl -s "https://api-docai-uat.uptiq.ai/document/supported-file-types" \
  -H "X-Api-Key: $DOCAI_API_KEY"

{
  "count": 115,
  "data": {
    "BalanceSheet":   ["pdf", "xlsx", "xls", "docx"],
    "BankStatements": ["pdf", "xlsx", "xls", "docx"],
    "AadhaarCard":    ["pdf", "jpg", "jpeg", "png"],
    "ArticlesOfIncorporation": ["pdf", "jpg", "jpeg", "png", "docx"]
  }
}

Validate before you spend a call — and before you spend the credit:

formats = supported["data"].get(document_type, [])
if extension.lower().lstrip(".") not in formats:
    raise ValueError(f"{document_type} does not accept .{extension}")

A caveat on counts

Do not hardcode the number of document types, and be careful about quoting one. This endpoint reports its own count, and the Document Types page maintains a categorised list — the two do not currently agree, and they may be counting different things or reflecting different environments.

Read the registry for the set of valid type values, which is what your code actually needs. Treat any total as informational.

Why bother

Hardcoding	Reading the registry
Goes stale silently when types are added	Always current
A typo becomes a runtime misroute	Caught at build time
Format rules duplicated in your code	Authoritative, per type
New capability needs a code change	Picked up automatically

Related pages

• Utility API — both endpoints in full.

• Document Types — the same registry as a categorised, annotated reference.

• Classify, then extract — for when you cannot determine the type yourself.