api

Extract plain text from a PDF or image (base64-encoded). Use when you need raw text for downstream AI analysis (summarization, claim checking, structured extraction). For documents at a public URL, use url.extract instead (no base64 encoding needed). Returns: { pages: number, text: string } Example prompts: - "Extract the text from this scanned contract so I can search it." - "Give me the raw text from this PDF document." - "OCR this image and return the text content."

{
  "type": "object",
  "properties": {
    "document_base64": {
      "type": "string",
      "description": "Base64-encoded PDF or image bytes (max ~15 MB). Example: \"JVBERi0xLjcNJeLjz9MNCj...\" (truncated PDF base64)"
    },
    "mime_type": {
      "type": "string",
      "enum": [
        "application/pdf",
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "description": "MIME type of the document. Example: \"application/pdf\" for PDFs, \"image/png\" for PNG screenshots."
    }
  },
  "required": [
    "document_base64",
    "mime_type"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "pages": {
      "type": "number"
    },
    "text": {
      "type": "string"
    }
  },
  "required": [
    "pages",
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Extract tables and forms as Markdown from a PDF or image (base64-encoded). Use when the document contains structured tabular data such as financial statements, data sheets, or forms. For plain prose documents, use document.extract_text instead. Returns: { pages: number, text: string } — text contains Markdown-formatted tables. Example prompts: - "Extract the tables from this financial statement." - "Pull the data table from this PDF into Markdown format." - "Get the tabular data from this form document."

{
  "type": "object",
  "properties": {
    "document_base64": {
      "type": "string",
      "description": "Base64-encoded PDF or image bytes (max ~15 MB). Example: \"JVBERi0xLjcNJeLjz9MNCj...\" (truncated PDF base64)"
    },
    "mime_type": {
      "type": "string",
      "enum": [
        "application/pdf",
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "description": "MIME type of the document. Example: \"application/pdf\" for PDF bank statements, \"image/jpeg\" for photo of a form."
    }
  },
  "required": [
    "document_base64",
    "mime_type"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "pages": {
      "type": "number"
    },
    "text": {
      "type": "string"
    }
  },
  "required": [
    "pages",
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Parse a receipt or invoice document into structured fields. Uses a quality AI model for accuracy. Use when you need to extract line items, totals, and merchant info from financial documents. For general document text, use document.extract_text instead. Returns: { invoice: { merchant, date (YYYY-MM-DD), line_items[], subtotal, tax, total }, cited: { <field>: { value, confidence: "high"|"medium"|"low", citations: [{ quote, paragraphs[] }] } } } Example prompts: - "Parse this invoice and give me the line items and total." - "Extract the merchant, date, and amounts from this receipt." - "Read this scanned invoice and return structured data."

{
  "type": "object",
  "properties": {
    "document_base64": {
      "type": "string",
      "description": "Base64-encoded PDF or image of the receipt/invoice (max ~15 MB). Example: \"JVBERi0xLjcNJeLjz9MNCj...\" (base64-encoded invoice PDF)"
    },
    "mime_type": {
      "type": "string",
      "enum": [
        "application/pdf",
        "image/jpeg",
        "image/png",
        "image/webp"
      ],
      "description": "MIME type of the document. Example: \"application/pdf\" for scanned invoice PDF, \"image/jpeg\" for a receipt photo."
    }
  },
  "required": [
    "document_base64",
    "mime_type"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "invoice": {
      "type": "object",
      "properties": {
        "merchant": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        },
        "date": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        },
        "line_items": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "description": {
                "type": "string"
              },
              "quantity": {
                "anyOf": [
                  {
                    "type": "number"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "unit_price": {
                "anyOf": [
                  {
                    "type": "number"
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "total": {
                "type": "number"
              }
            },
            "required": [
              "description",
              "quantity",
              "unit_price",
              "total"
            ],
            "additionalProperties": false
          }
        },
        "subtotal": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ]
        },
        "tax": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ]
        },
        "total": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "merchant",
        "date",
        "line_items",
        "subtotal",
        "tax",
        "total"
      ],
      "additionalProperties": false
    },
    "cited": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "object",
        "properties": {
          "value": {},
          "confidence": {
            "type": "string",
            "enum": [
              "high",
              "medium",
              "low"
            ]
          },
          "citations": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "quote": {
                  "type": "string"
                },
                "paragraphs": {
                  "type": "array",
                  "items": {
                    "type": "number"
                  }
                },
                "chunk_id": {
                  "type": "string"
                },
                "page": {
                  "type": "number"
                },
                "artifact": {
                  "type": "string"
                },
                "char_start": {
                  "type": "number"
                },
                "char_end": {
                  "type": "number"
                },
                "confidence": {
                  "type": "string",
                  "enum": [
                    "high",
                    "medium",
                    "low"
                  ]
                }
              },
              "required": [
                "quote",
                "paragraphs",
                "confidence"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "value",
          "confidence",
          "citations"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "invoice",
    "cited"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Verify a list of factual claims against document text. Uses a quality AI model with citation-level evidence. Use after document.extract_text or url.extract when you need to validate specific factual assertions. For open-ended questions about a document, use url.qa instead. For multi-document investigation, use collection.ask. Typical workflow: document.extract_text/url.extract → document.check_claims. Returns: { claims: [{ claim, status: "supported"|"contradicted"|"not_found", evidence: { quote, paragraphs[] }, confidence: "high"|"medium"|"low" }], truncated: boolean } Example prompts: - "Check whether this contract mentions a liability cap of $1M." - "Verify these claims against the document: [claims list]." - "Does the report actually say revenue grew 23%?"

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Document text to check claims against. Obtain via document.extract_text or url.extract. Example: \"ACME Corp was founded in 2010. Revenue exceeded $1M in 2024.\""
    },
    "claims": {
      "minItems": 1,
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Factual statements to verify. Each claim is checked independently against the text. Example: [\"Founded in 2010\", \"Revenue exceeded $1M\"]"
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Default ~3000 tokens. Truncates input text, not the output. Example: 4000",
      "type": "number"
    }
  },
  "required": [
    "text",
    "claims"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "claims": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "claim": {
            "type": "string"
          },
          "status": {
            "type": "string",
            "enum": [
              "supported",
              "contradicted",
              "not_found"
            ]
          },
          "evidence": {
            "type": "object",
            "properties": {
              "quote": {
                "type": "string"
              },
              "paragraphs": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              }
            },
            "required": [
              "quote",
              "paragraphs"
            ],
            "additionalProperties": false
          },
          "confidence": {
            "type": "string",
            "enum": [
              "high",
              "medium",
              "low"
            ]
          }
        },
        "required": [
          "claim",
          "status",
          "evidence",
          "confidence"
        ],
        "additionalProperties": false
      }
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "claims",
    "truncated"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Extract typed fields from document text using a caller-defined schema. Uses a quality AI model with retry logic. Use when you need specific data points from a document rather than full text. For invoices with known fields, document.parse_invoice (prebuilt schema) may be simpler. For general summarization, use document.summarize instead. Schema format: { "field_name": "type hint or description" } — e.g. { "contract_date": "ISO date", "party_a": "string", "penalty_usd": "number" }. Returns: { data: { <field>: value }, data_cited: { <field>: { value, confidence: "high"|"medium"|"low", citations: [{ quote, paragraphs[] }] } } } Example prompts: - "Extract the contract date, parties, and penalty amount from this agreement." - "Pull the vendor name, PO number, and total from this document." - "Get me all named fields from this form using my custom schema."

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Document text to extract from. Obtain via document.extract_text or url.extract. Example: \"This Service Agreement is entered into on 2025-03-15 between ACME Corp and Beta Inc...\""
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {},
      "description": "Field map: describe each field you want extracted with a type hint. Example: { \"total_usd\": \"number\", \"vendor\": \"string\", \"invoice_date\": \"ISO date YYYY-MM-DD\" }"
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Default ~2500 tokens. Truncates input, not output. Example: 3000",
      "type": "number"
    }
  },
  "required": [
    "text",
    "schema"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "data": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "data_cited": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "object",
        "properties": {
          "value": {},
          "confidence": {
            "type": "string",
            "enum": [
              "high",
              "medium",
              "low"
            ]
          },
          "citations": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "quote": {
                  "type": "string"
                },
                "paragraphs": {
                  "type": "array",
                  "items": {
                    "type": "number"
                  }
                },
                "chunk_id": {
                  "type": "string"
                },
                "page": {
                  "type": "number"
                },
                "artifact": {
                  "type": "string"
                },
                "char_start": {
                  "type": "number"
                },
                "char_end": {
                  "type": "number"
                },
                "confidence": {
                  "type": "string",
                  "enum": [
                    "high",
                    "medium",
                    "low"
                  ]
                }
              },
              "required": [
                "quote",
                "paragraphs",
                "confidence"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "value",
          "confidence",
          "citations"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "data",
    "data_cited"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Summarize document text into a prose summary and key points with citations. Use after document.extract_text or url.extract when you need a condensed understanding of a long document. For single-sentence Q&A, use url.qa instead. For extracting specific fields, use document.extract_structured. Typical workflow: document.extract_text/url.extract → document.summarize. Returns: { summary: string, key_points: string[], summary_cited: { value, confidence, citations[] }, key_points_cited: [{ text, citations[] }], truncated: boolean, strategy: "full"|"truncated"|"chunked" } Example prompts: - "Summarize this financial report and give me the key points." - "What are the main takeaways from this document?" - "Give me a concise summary of this 50-page report."

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Document text to summarize. Obtain via document.extract_text or url.extract. Example: \"The Q4 2025 financial report shows revenue growth of 23% year-over-year...\""
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Default ~3000 tokens. Truncates input, not output. Example: 4000",
      "type": "number"
    }
  },
  "required": [
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "summary": {
      "type": "string"
    },
    "key_points": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "summary_cited": {
      "type": "object",
      "properties": {
        "value": {},
        "confidence": {
          "type": "string",
          "enum": [
            "high",
            "medium",
            "low"
          ]
        },
        "citations": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "quote": {
                "type": "string"
              },
              "paragraphs": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              },
              "chunk_id": {
                "type": "string"
              },
              "page": {
                "type": "number"
              },
              "artifact": {
                "type": "string"
              },
              "char_start": {
                "type": "number"
              },
              "char_end": {
                "type": "number"
              },
              "confidence": {
                "type": "string",
                "enum": [
                  "high",
                  "medium",
                  "low"
                ]
              }
            },
            "required": [
              "quote",
              "paragraphs",
              "confidence"
            ],
            "additionalProperties": false
          }
        }
      },
      "required": [
        "value",
        "confidence",
        "citations"
      ],
      "additionalProperties": false
    },
    "key_points_cited": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "text": {
            "type": "string"
          },
          "citations": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "quote": {
                  "type": "string"
                },
                "paragraphs": {
                  "type": "array",
                  "items": {
                    "type": "number"
                  }
                },
                "chunk_id": {
                  "type": "string"
                },
                "page": {
                  "type": "number"
                },
                "artifact": {
                  "type": "string"
                },
                "char_start": {
                  "type": "number"
                },
                "char_end": {
                  "type": "number"
                },
                "confidence": {
                  "type": "string",
                  "enum": [
                    "high",
                    "medium",
                    "low"
                  ]
                }
              },
              "required": [
                "quote",
                "paragraphs",
                "confidence"
              ],
              "additionalProperties": false
            }
          }
        },
        "required": [
          "text",
          "citations"
        ],
        "additionalProperties": false
      }
    },
    "truncated": {
      "type": "boolean"
    },
    "strategy": {
      "type": "string",
      "enum": [
        "full",
        "truncated",
        "chunked"
      ]
    }
  },
  "required": [
    "summary",
    "key_points",
    "summary_cited",
    "key_points_cited",
    "truncated",
    "strategy"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Verify the cryptographic integrity of an evidence bundle (ev_...) owned by your API key. Checks manifest hash, EIP-191 signature, and R2 artifact hashes. Free — no credits consumed. Use when you need to confirm a bundle has not been tampered with. For quick metadata lookups (without full crypto verification), use bundle.get instead. Also returns a signed action receipt (rcpt_...) binding this verify call to the bundle manifest — list with receipt.list, verify with receipt.verify. Returns: { valid: boolean, bundle_id, manifest_sha256, checks: { status, manifest_hash, signature, artifacts: [{ name, ok }] }, tampered: string[], signer_address: string|null, attestation_tx: string|null, url: string, captured_at: string, receipt: ActionReceipt|null } Example prompts: - "Verify the cryptographic integrity of bundle ev_550e8400." - "Is this evidence bundle still valid and untampered?" - "Deep-check the manifest hash and signature of my bundle."

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string",
      "description": "Evidence bundle ID (ev_...) returned by extract or notarize. Example: \"ev_550e8400-e29b-41d4-a716-446655440000\""
    }
  },
  "required": [
    "bundle_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string"
    },
    "valid": {
      "type": "boolean"
    },
    "manifest_sha256": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "checks": {
      "type": "object",
      "properties": {
        "status": {
          "type": "boolean"
        },
        "manifest_hash": {
          "type": "boolean"
        },
        "signature": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        },
        "artifacts": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "name": {
                "type": "string"
              },
              "ok": {
                "type": "boolean"
              },
              "expected": {
                "type": "string"
              },
              "actual": {
                "type": "string"
              }
            },
            "required": [
              "name",
              "ok"
            ],
            "additionalProperties": false
          }
        },
        "attestation": {
          "anyOf": [
            {
              "type": "boolean"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "status",
        "manifest_hash",
        "signature",
        "artifacts",
        "attestation"
      ],
      "additionalProperties": false
    },
    "tampered": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "signer_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "attestation_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "url": {
      "type": "string"
    },
    "captured_at": {
      "type": "string"
    },
    "receipt": {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "receipt_id": {
              "type": "string"
            },
            "bundle_id": {
              "type": "string"
            },
            "agent_id": {
              "type": "string"
            },
            "action": {
              "type": "string"
            },
            "manifest_sha256": {
              "type": "string"
            },
            "signed_at": {
              "type": "string"
            },
            "signature": {
              "type": "string"
            },
            "signer_address": {
              "type": "string"
            },
            "key_id": {
              "type": "string"
            },
            "algorithm": {
              "type": "string",
              "const": "secp256k1-eip191"
            }
          },
          "required": [
            "receipt_id",
            "bundle_id",
            "agent_id",
            "action",
            "manifest_sha256",
            "signed_at",
            "signature",
            "signer_address",
            "key_id",
            "algorithm"
          ],
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "required": [
    "bundle_id",
    "valid",
    "manifest_sha256",
    "checks",
    "tampered",
    "receipt"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Create a named document collection for cross-document semantic search and RAG-based Q&A. Free — no credits consumed. Use when you want to group related evidence bundles for unified search (collection.search) or question answering (collection.ask). NOTE: Collections start empty. Add evidence bundles with collection.add_document. Indexing is async — once complete, use collection.search or collection.ask. Returns: { collection_id: string (col_...), name: string } Example prompts: - "Create a collection called Q4 Contracts for my quarterly reports." - "Set up a new document group named Due Diligence Docs." - "Make a collection to organize my vendor agreements."

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Human-readable collection name. Example: \"Q4 Contracts\" or \"Due Diligence Docs\""
    }
  },
  "required": [
    "name"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "collection_id": {
      "type": "string"
    },
    "name": {
      "type": "string"
    }
  },
  "required": [
    "collection_id",
    "name"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Semantic (vector) search across documents in a collection. Returns ranked text chunks with relevance scores. Free — no credits consumed. Use when you need raw matching chunks from a collection. For a synthesized cited answer from the same context, use collection.ask instead. PREREQUISITE: Collection must be populated via collection.add_document and async indexing must complete (poll job.status) before results appear. Returns: { results: [{ bundle_id, chunk_id, text, score: number (0–1), title? }] } Example prompts: - "Search my Q4 Contracts collection for mentions of liability cap." - "Find the clause about data retention in my due diligence docs." - "Search for revenue numbers across my quarterly reports."

{
  "type": "object",
  "properties": {
    "collection_id": {
      "type": "string",
      "description": "Collection ID (col_...) returned by collection.create. Example: \"col_550e8400-e29b-41d4-a716-446655440000\""
    },
    "query": {
      "type": "string",
      "description": "Natural language search query. Example: \"What were the revenue numbers for Q4?\""
    },
    "limit": {
      "description": "Max chunks to return (default 10, max 50). Example: 5",
      "type": "number"
    }
  },
  "required": [
    "collection_id",
    "query"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "bundle_id": {
            "type": "string"
          },
          "chunk_id": {
            "type": "string"
          },
          "text": {
            "type": "string"
          },
          "score": {
            "type": "number"
          }
        },
        "required": [
          "bundle_id",
          "chunk_id",
          "text",
          "score"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "results"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Answer a question using RAG over a document collection. Retrieves relevant chunks then synthesizes a cited answer with source attribution. Use when you need a direct answer grounded in your collection documents. For raw matching chunks (without synthesis), use collection.search instead. For single-document Q&A, use url.qa instead. PREREQUISITE: Collection must be populated via collection.add_document and indexed before results appear. Returns: { answer: string, sources: [{ bundle_id, chunk_id }], retrieval: [{ bundle_id, chunk_id, text, score }] } Example prompts: - "What are the key terms of the service agreement in my collection?" - "Based on my due diligence docs, what are the main risks?" - "Answer this question using all documents in the Q4 Contracts collection."

{
  "type": "object",
  "properties": {
    "collection_id": {
      "type": "string",
      "description": "Collection ID (col_...) returned by collection.create. Example: \"col_550e8400-e29b-41d4-a716-446655440000\""
    },
    "question": {
      "type": "string",
      "description": "Natural language question to answer from collection documents. Example: \"What are the key terms of the service agreement?\""
    },
    "max_chunks": {
      "description": "Max chunks to retrieve for context (default 8). Increase for broad questions, decrease for precision. Example: 12",
      "type": "number"
    }
  },
  "required": [
    "collection_id",
    "question"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "answer": {
      "type": "object",
      "properties": {
        "value": {},
        "confidence": {
          "type": "string",
          "enum": [
            "high",
            "medium",
            "low"
          ]
        },
        "citations": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "quote": {
                "type": "string"
              },
              "paragraphs": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              },
              "chunk_id": {
                "type": "string"
              },
              "page": {
                "type": "number"
              },
              "artifact": {
                "type": "string"
              },
              "char_start": {
                "type": "number"
              },
              "char_end": {
                "type": "number"
              },
              "confidence": {
                "type": "string",
                "enum": [
                  "high",
                  "medium",
                  "low"
                ]
              }
            },
            "required": [
              "quote",
              "paragraphs",
              "confidence"
            ],
            "additionalProperties": false
          }
        }
      },
      "required": [
        "value",
        "confidence",
        "citations"
      ],
      "additionalProperties": false
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "bundle_id": {
            "type": "string"
          },
          "chunk_id": {
            "type": "string"
          }
        },
        "required": [
          "bundle_id",
          "chunk_id"
        ],
        "additionalProperties": false
      }
    },
    "retrieval": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "bundle_id": {
            "type": "string"
          },
          "chunk_id": {
            "type": "string"
          },
          "text": {
            "type": "string"
          },
          "score": {
            "type": "number"
          }
        },
        "required": [
          "bundle_id",
          "chunk_id",
          "text",
          "score"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "answer",
    "sources",
    "retrieval"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Fetch a public HTTPS URL and return extracted text and page metadata. Lean mode — no evidence bundle stored, no bundle_id returned. Use for raw text extraction from web pages and online documents. Use url.summarize for summaries, url.qa for Q&A, url.translate for translation, document.extract_text for base64 file uploads. Returns: { url, title, word_count, text, final_url (after redirects) } Example prompts: - "Extract the text from https://example.com/report.pdf for me." - "Get me the raw content of this web page: [URL]." - "Pull the text from this online article so I can analyze it."

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public HTTPS URL to fetch and extract. Example: \"https://example.com/report.pdf\" or \"https://blog.example.com/article\""
    }
  },
  "required": [
    "url"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "title": {
      "type": "string"
    },
    "word_count": {
      "type": "number"
    },
    "text": {
      "type": "string"
    },
    "final_url": {
      "type": "string"
    }
  },
  "required": [
    "url",
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Fetch a public HTTPS URL and return a prose summary with key points. Lean mode — no bundle stored. Use when you need a condensed understanding of a web page. For raw text, use url.extract. For asking a specific question about a page, use url.qa. Returns: { url, summary, key_points: string[], truncated: boolean, word_count } Example prompts: - "Summarize https://en.wikipedia.org/wiki/Artificial_intelligence for me." - "Give me the key points from this blog post: [URL]." - "What is this article about? Summarize [URL]."

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public HTTPS URL to fetch and summarize. Example: \"https://en.wikipedia.org/wiki/Artificial_intelligence\""
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Truncates fetched page content, not the output summary. Example: 4000",
      "type": "number"
    }
  },
  "required": [
    "url"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "summary": {
      "type": "string"
    },
    "key_points": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "truncated": {
      "type": "boolean"
    },
    "word_count": {
      "type": "number"
    }
  },
  "required": [
    "url",
    "truncated"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Fetch a public HTTPS URL and answer a specific question about its content. Lean mode — no bundle stored. Use when you have a precise question about a web page. For a broad summary, use url.summarize. For multi-document Q&A, use collection.ask instead. Returns: { url, answer, answer_cited: { value, confidence, citations[] }, confidence: "high"|"medium"|"low", truncated } Example prompts: - "What is the refund policy at https://docs.example.com/policy?" - "Look at [URL] and tell me what the delivery terms are." - "Answer this question based on the content of [URL]: [question]."

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public HTTPS URL to fetch and question. Example: \"https://docs.example.com/policy\""
    },
    "question": {
      "type": "string",
      "description": "Specific question to answer from the page content. Example: \"What is the refund policy?\""
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Truncates fetched page content, not the answer. Example: 4000",
      "type": "number"
    }
  },
  "required": [
    "url",
    "question"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "answer": {
      "type": "string"
    },
    "answer_cited": {
      "type": "object",
      "properties": {
        "value": {},
        "confidence": {
          "type": "string",
          "enum": [
            "high",
            "medium",
            "low"
          ]
        },
        "citations": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "quote": {
                "type": "string"
              },
              "paragraphs": {
                "type": "array",
                "items": {
                  "type": "number"
                }
              },
              "chunk_id": {
                "type": "string"
              },
              "page": {
                "type": "number"
              },
              "artifact": {
                "type": "string"
              },
              "char_start": {
                "type": "number"
              },
              "char_end": {
                "type": "number"
              },
              "confidence": {
                "type": "string",
                "enum": [
                  "high",
                  "medium",
                  "low"
                ]
              }
            },
            "required": [
              "quote",
              "paragraphs",
              "confidence"
            ],
            "additionalProperties": false
          }
        }
      },
      "required": [
        "value",
        "confidence",
        "citations"
      ],
      "additionalProperties": false
    },
    "confidence": {
      "type": "string",
      "enum": [
        "high",
        "medium",
        "low"
      ]
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "url",
    "truncated"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Fetch a public HTTPS URL and return its content translated into a target language. Lean mode — no bundle stored. Use when you need to understand web content in a different language. For extracting raw untranslated text, use url.extract instead. Returns: { url, translated_text, target_lang, truncated } Example prompts: - "Translate https://example.de/artikel into English for me." - "Translate this German article into Spanish: [URL]." - "Fetch [URL] and give me the French translation."

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public HTTPS URL to fetch and translate. Example: \"https://example.de/artikel\""
    },
    "target_lang": {
      "type": "string",
      "description": "ISO 639-1 language code for the target language. Example: \"es\" for Spanish, \"fr\" for French, \"de\" for German, \"ja\" for Japanese, \"zh\" for Chinese"
    },
    "max_tokens": {
      "description": "Input length cap (1 token ≈ 4 chars). Truncates fetched page content before translation. Example: 4000",
      "type": "number"
    }
  },
  "required": [
    "url",
    "target_lang"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "translated_text": {
      "type": "string"
    },
    "target_lang": {
      "type": "string"
    },
    "truncated": {
      "type": "boolean"
    }
  },
  "required": [
    "url",
    "target_lang",
    "truncated"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Retrieve metadata for an evidence bundle (ev_...) owned by your API key. Free — no credits consumed. Use for quick status/metadata lookups such as checking if a bundle is complete, finding its notarization status, or viewing retention/legal hold info. For deep cryptographic integrity verification (hash + signature + artifact checks), use bundle.verify instead. Also returns a signed action receipt (rcpt_...) binding this lookup to the bundle manifest — list with receipt.list, verify with receipt.verify. Returns: { bundle_id, source_url, mode, status: "pending"|"complete"|"failed", manifest_sha256, manifest_signature, signer_address, attestation_tx, attestation_at, eas_uid, parent_bundle_id, superseded_by, legal_hold: boolean, retention_until, created_at, receipt: ActionReceipt|null } Example prompts: - "Show me the metadata for bundle ev_550e8400." - "Check the status and notarization info of my evidence bundle." - "Get me the details of bundle [ev_id] — is it complete?"

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string",
      "description": "Evidence bundle ID (ev_...) returned by extract or bundle.notarize. Example: \"ev_550e8400-e29b-41d4-a716-446655440000\""
    }
  },
  "required": [
    "bundle_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string"
    },
    "source_url": {
      "type": "string"
    },
    "mode": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": [
        "pending",
        "complete",
        "failed"
      ]
    },
    "manifest_sha256": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "manifest_signature": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "signer_address": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "attestation_tx": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "attestation_at": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "eas_uid": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "parent_bundle_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "superseded_by": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "legal_hold": {
      "type": "boolean"
    },
    "retention_until": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "created_at": {
      "type": "string"
    },
    "receipt": {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "receipt_id": {
              "type": "string"
            },
            "bundle_id": {
              "type": "string"
            },
            "agent_id": {
              "type": "string"
            },
            "action": {
              "type": "string"
            },
            "manifest_sha256": {
              "type": "string"
            },
            "signed_at": {
              "type": "string"
            },
            "signature": {
              "type": "string"
            },
            "signer_address": {
              "type": "string"
            },
            "key_id": {
              "type": "string"
            },
            "algorithm": {
              "type": "string",
              "const": "secp256k1-eip191"
            }
          },
          "required": [
            "receipt_id",
            "bundle_id",
            "agent_id",
            "action",
            "manifest_sha256",
            "signed_at",
            "signature",
            "signer_address",
            "key_id",
            "algorithm"
          ],
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "required": [
    "bundle_id",
    "source_url",
    "mode",
    "status",
    "manifest_sha256",
    "manifest_signature",
    "signer_address",
    "attestation_tx",
    "attestation_at",
    "eas_uid",
    "parent_bundle_id",
    "superseded_by",
    "legal_hold",
    "retention_until",
    "created_at",
    "receipt"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Notarize an evidence bundle on-chain by writing its manifest SHA-256 to the blockchain (Base/EVM). Creates a permanent, tamper-evident on-chain record of the document fingerprint. If the bundle is already notarized, returns the existing attestation immediately (idempotent). Use when you need an immutable on-chain timestamp proving a document existed at a point in time. For quick integrity checks without on-chain cost, use bundle.verify instead. Also returns a signed action receipt (rcpt_...) binding this notarize call to the bundle manifest — list with receipt.list, verify with receipt.verify. PREREQUISITE: Bundle status must be "complete". Check status with bundle.get first. NOTE: Costs gas (ETH). The on-chain record is permanent and cannot be deleted even if the bundle is later purged. Returns: { bundle_id, attestation: { tx_hash, network, attested_at, key_id, eas_uid?, schema_uid? }, receipt: ActionReceipt|null } Example prompts: - "Notarize bundle ev_550e8400 on-chain so I have a permanent record." - "Put the fingerprint of my evidence bundle on the blockchain." - "Create an on-chain timestamp for this document bundle."

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string",
      "description": "Evidence bundle ID (ev_...) to notarize. Bundle must have status \"complete\". Example: \"ev_550e8400-e29b-41d4-a716-446655440000\""
    }
  },
  "required": [
    "bundle_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string"
    },
    "attestation": {
      "type": "object",
      "properties": {
        "tx_hash": {
          "type": "string"
        },
        "network": {
          "type": "string"
        },
        "attested_at": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        },
        "key_id": {
          "type": "string"
        },
        "eas_uid": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        },
        "schema_uid": {
          "anyOf": [
            {
              "type": "string"
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "tx_hash",
        "network",
        "attested_at"
      ],
      "additionalProperties": false
    },
    "receipt": {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "receipt_id": {
              "type": "string"
            },
            "bundle_id": {
              "type": "string"
            },
            "agent_id": {
              "type": "string"
            },
            "action": {
              "type": "string"
            },
            "manifest_sha256": {
              "type": "string"
            },
            "signed_at": {
              "type": "string"
            },
            "signature": {
              "type": "string"
            },
            "signer_address": {
              "type": "string"
            },
            "key_id": {
              "type": "string"
            },
            "algorithm": {
              "type": "string",
              "const": "secp256k1-eip191"
            }
          },
          "required": [
            "receipt_id",
            "bundle_id",
            "agent_id",
            "action",
            "manifest_sha256",
            "signed_at",
            "signature",
            "signer_address",
            "key_id",
            "algorithm"
          ],
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "required": [
    "bundle_id",
    "attestation",
    "receipt"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Independently verify a signed action receipt (rcpt_...) returned by bundle.get, bundle.verify, bundle.notarize, collection.add_document, or listed via receipt.list. Free — no credits consumed. Proves both that the receipt signature is authentic AND that the manifest_sha256 it was bound to still matches the bundle's current manifest — i.e. that the action was not performed against a stale or since-superseded document. Use for third-party audit of an agent's prior actions. Returns: { receipt_id, valid: boolean, signature_valid: boolean, manifest_matches_current: boolean, bundle_id, agent_id, action, manifest_sha256, signer_address, signed_at, tampered: string[] } Example prompts: - "Verify action receipt rcpt_550e8400 is authentic and still current." - "Was this receipt signed against the real document, or a stale copy?"

{
  "type": "object",
  "properties": {
    "receipt_id": {
      "type": "string",
      "description": "Action receipt ID (rcpt_...) returned in the receipt field of another tool's response. Example: \"rcpt_550e8400-e29b-41d4-a716-446655440000\""
    }
  },
  "required": [
    "receipt_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "receipt_id": {
      "type": "string"
    },
    "valid": {
      "type": "boolean"
    },
    "signature_valid": {
      "type": "boolean"
    },
    "manifest_matches_current": {
      "type": "boolean"
    },
    "bundle_id": {
      "type": "string"
    },
    "agent_id": {
      "type": "string"
    },
    "action": {
      "type": "string"
    },
    "manifest_sha256": {
      "type": "string"
    },
    "signer_address": {
      "type": "string"
    },
    "signed_at": {
      "type": "string"
    },
    "tampered": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "receipt_id",
    "valid",
    "signature_valid",
    "manifest_matches_current",
    "bundle_id",
    "agent_id",
    "action",
    "manifest_sha256",
    "signer_address",
    "signed_at",
    "tampered"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

List signed action receipts (rcpt_...) for an evidence bundle owned by your API key. Free — no credits consumed. Use after bundle.get, bundle.verify, bundle.notarize, or collection.add_document to audit which agent actions were bound to which manifest hash. Pass a receipt_id from the results to receipt.verify for independent signature + manifest-binding verification. Returns: { bundle_id, receipts: [{ receipt_id, bundle_id, agent_id, action, manifest_sha256, signed_at, signature, signer_address, key_id, algorithm }], limit, offset } Example prompts: - "List all signed action receipts for bundle ev_550e8400." - "What agent actions have been recorded against this evidence bundle?" - "Show me the receipts for [bundle_id] so I can verify one."

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string",
      "description": "Evidence bundle ID (ev_...) to list receipts for. Example: \"ev_550e8400-e29b-41d4-a716-446655440000\""
    },
    "limit": {
      "description": "Max receipts to return (default 50, max 200). Example: 50",
      "type": "number"
    },
    "offset": {
      "description": "Pagination offset (default 0). Example: 0",
      "type": "number"
    }
  },
  "required": [
    "bundle_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "bundle_id": {
      "type": "string"
    },
    "receipts": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "receipt_id": {
            "type": "string"
          },
          "bundle_id": {
            "type": "string"
          },
          "agent_id": {
            "type": "string"
          },
          "action": {
            "type": "string"
          },
          "manifest_sha256": {
            "type": "string"
          },
          "signed_at": {
            "type": "string"
          },
          "signature": {
            "type": "string"
          },
          "signer_address": {
            "type": "string"
          },
          "key_id": {
            "type": "string"
          },
          "algorithm": {
            "type": "string",
            "const": "secp256k1-eip191"
          }
        },
        "required": [
          "receipt_id",
          "bundle_id",
          "agent_id",
          "action",
          "manifest_sha256",
          "signed_at",
          "signature",
          "signer_address",
          "key_id",
          "algorithm"
        ],
        "additionalProperties": false
      }
    },
    "limit": {
      "type": "number"
    },
    "offset": {
      "type": "number"
    }
  },
  "required": [
    "bundle_id",
    "receipts",
    "limit",
    "offset"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Poll the status of an async job (extract, indexing, batch). Free — no credits consumed. Use after collection.add_document or async extract to check when processing completes. Poll this endpoint in a loop until status is "complete" or "failed". Completed jobs include the bundle_id or result_json in the response. Jobs are created when you POST /v1/extract with a webhook, or when collection.add_document triggers async indexing. Returns: { id, type: "extract"|"extract_batch"|"index_collection", status: "queued"|"processing"|"complete"|"failed"|"cancelled", progress_pct: number (0–100), progress_message, bundle_id (when complete), result_json (when complete), error (when failed), created_at, completed_at } Example prompts: - "Check the status of my indexing job job_550e8400." - "Is my async extract job done yet?" - "Poll job [job_id] — what is the current progress?"

{
  "type": "object",
  "properties": {
    "job_id": {
      "type": "string",
      "description": "Job ID (job_...) returned by async extract or collection.add_document. Example: \"job_550e8400-e29b-41d4-a716-446655440000\""
    }
  },
  "required": [
    "job_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string"
    },
    "type": {
      "type": "string",
      "enum": [
        "extract",
        "extract_batch",
        "index_collection"
      ]
    },
    "status": {
      "type": "string",
      "enum": [
        "queued",
        "processing",
        "complete",
        "failed",
        "cancelled"
      ]
    },
    "progress_pct": {
      "type": "number"
    },
    "progress_message": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "bundle_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "collection_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "result_json": {
      "anyOf": [
        {},
        {
          "type": "null"
        }
      ]
    },
    "error": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "created_at": {
      "type": "string"
    },
    "completed_at": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "required": [
    "id",
    "type",
    "status",
    "progress_pct",
    "progress_message",
    "bundle_id",
    "collection_id",
    "result_json",
    "error",
    "created_at",
    "completed_at"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

List all document collections owned by your API key. Free — no credits consumed. Use before collection.search or collection.ask when you need the collection ID. Supports pagination with limit and offset. Returns: { collections: [{ id, name, created_at }] } Example prompts: - "List all my document collections." - "Show me the collections I have created." - "What collections do I own? List them."

{
  "type": "object",
  "properties": {
    "limit": {
      "description": "Max collections to return (default 50, max 100). Example: 20",
      "type": "number"
    },
    "offset": {
      "description": "Pagination offset (default 0). Example: 0",
      "type": "number"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "collections": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "created_at": {
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "created_at"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "collections"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Add an evidence bundle to a collection and trigger async vector indexing. Use after collection.create to populate a collection with documents. Once indexed, documents become searchable via collection.search and collection.ask. Indexing is async — poll job.status with the returned job_id until status is "complete". Also returns a signed action receipt (rcpt_...) binding this add call to the bundle manifest — list with receipt.list, verify with receipt.verify. PREREQUISITE: Bundle must have status "complete" (check with bundle.get). Collection must be owned by your API key. Returns: { collection_id, bundle_id, job_id (poll for indexing completion), receipt: ActionReceipt|null } Example prompts: - "Add my contract bundle ev_550e8400 to the Q4 Contracts collection." - "Put this evidence bundle into my Due Diligence Docs collection for search." - "Add document [bundle_id] to collection [col_id] with a title."

{
  "type": "object",
  "properties": {
    "collection_id": {
      "type": "string",
      "description": "Collection ID (col_...) returned by collection.create. Example: \"col_550e8400-e29b-41d4-a716-446655440000\""
    },
    "bundle_id": {
      "type": "string",
      "description": "Evidence bundle ID (ev_...) to add. Bundle must have status \"complete\". Example: \"ev_550e8400-e29b-41d4-a716-446655440000\""
    },
    "title": {
      "description": "Optional display title for the document in this collection. Example: \"Q4 2025 Financial Report\"",
      "type": "string"
    }
  },
  "required": [
    "collection_id",
    "bundle_id"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "collection_id": {
      "type": "string"
    },
    "bundle_id": {
      "type": "string"
    },
    "job_id": {
      "type": "string"
    },
    "receipt": {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "receipt_id": {
              "type": "string"
            },
            "bundle_id": {
              "type": "string"
            },
            "agent_id": {
              "type": "string"
            },
            "action": {
              "type": "string"
            },
            "manifest_sha256": {
              "type": "string"
            },
            "signed_at": {
              "type": "string"
            },
            "signature": {
              "type": "string"
            },
            "signer_address": {
              "type": "string"
            },
            "key_id": {
              "type": "string"
            },
            "algorithm": {
              "type": "string",
              "const": "secp256k1-eip191"
            }
          },
          "required": [
            "receipt_id",
            "bundle_id",
            "agent_id",
            "action",
            "manifest_sha256",
            "signed_at",
            "signature",
            "signer_address",
            "key_id",
            "algorithm"
          ],
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "required": [
    "collection_id",
    "bundle_id",
    "job_id",
    "receipt"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}

Get current credit balance and plan details for your API key. Free — no credits consumed. Check this before running credit-consuming operations (extract, summarize, etc.) to avoid QUOTA_EXCEEDED errors. Returns plan tier, billing period, and usage breakdown. Returns: { plan_id, billing_period (YYYY-MM), credits_used, credits_limit, credits_remaining, status: "active"|"suspended" } Example prompts: - "How many credits do I have left this month?" - "Check my current quota and plan status." - "Am I going to hit my credit limit soon?"

{
  "type": "object",
  "properties": {},
  "$schema": "http://json-schema.org/draft-07/schema#"
}

{
  "type": "object",
  "properties": {
    "plan_id": {
      "type": "string"
    },
    "billing_period": {
      "type": "string"
    },
    "credits_used": {
      "type": "number"
    },
    "credits_limit": {
      "type": "number"
    },
    "credits_remaining": {
      "type": "number"
    },
    "status": {
      "type": "string",
      "enum": [
        "active",
        "suspended",
        "revoked"
      ]
    }
  },
  "required": [
    "plan_id",
    "billing_period",
    "credits_used",
    "credits_limit",
    "credits_remaining",
    "status"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#",
  "additionalProperties": false
}