# List proof URL: https://docs.hanzo.ai/docs/openapi/patent/get-patent-proof > Folds the caller's record set and answers the ordering question over it. `GET /v1/patent/proof` > [Patent →](https://docs.hanzo.ai/docs/openapi/patent) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | -------------------------------------- | | **Address** | `https://api.hanzo.ai/v1/patent/proof` | | **Method** | `GET` | | **Operation** | `get_patent_proof` | | **Auth** | `Authorization: Bearer $HANZO_API_KEY` | Folds the caller's record set and answers the ordering question over it. ?disclosure= proves one document's set, ?idea= proves one entry and everything citing it, and neither proves the whole org. The answer is computed per request and writes nothing. ## Request 3 fields. | Field | In | Type | Required | Description | | ------------ | ----- | ------ | -------- | -------------------------------------------------------------------------------------------------------------------------- | | `disclosure` | query | string | — | Disclosure folds the record set one document rests on, and reports on that set alone — which is what an attorney asks for. | | `idea` | query | string | — | Idea narrows to the one entry and the artifacts citing it. | | `project` | query | string | — | Project narrows inside the org; empty reads the caller's scope. | ## Response | Status | Body | Meaning | | --------- | ------------------ | ------- | | `200` | patent.PatentProof | ok | | `default` | problem-details | refused | `200` body — 34 fields. | Field | In | Type | Always | Description | | -------------------------- | ---- | -------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `anchor` | body | patent.PatentAnchor | — | | | `anchor.at` | body | string | — | At is when the commitment was made, RFC3339, when there is one. | | `anchor.commitment` | body | string | — | Commitment is the fold root the anchor would name. | | `anchor.reference` | body | string | — | Reference is where a third party can check it — a block, an index, a published headline. | | `anchor.status` | body | string | — | Status is unanchored or anchored. | | `coverage` | body | patent.PatentCoverage | — | | | `coverage.approvals` | body | integer (int64) | — | Approvals is how many decisions it covered. | | `coverage.disclosures` | body | integer (int64) | — | Disclosures is how many documents it covered. | | `coverage.ideas` | body | integer (int64) | — | Ideas is how many conception entries the fold covered. | | `coverage.implementations` | body | integer (int64) | — | Implementations is how many implementation records it covered. | | `coverage.versions` | body | integer (int64) | — | Versions is how many RETAINED versions were folded, which is at least the sum above and is the number that says corrections happened. | | `gaps` | body | patent.PatentGap\[] | — | Gaps names every field of the covered records that states nothing, with how many records leave it unstated. | | `gaps[].field` | body | string | — | Field is the wire name, e.g. prior\_art. | | `gaps[].missing` | body | integer (int64) | — | Missing is how many covered records leave it empty. | | `gaps[].why` | body | string | — | Why names what the absence costs, so a gap is a decision to fix rather than a lint warning. | | `order` | body | patent.PatentOrderCheck\[] | — | Order is one verdict per implementation-idea pair. | | `order[].gap_seq` | body | integer (int64) | — | GapSeq is how many appends separate them, negative when the implementation precedes the idea. | | `order[].idea` | body | string | — | Idea is the conception it cites. | | `order[].implementation` | body | string | — | Implementation is the artifact being examined. | | `order[].verdict` | body | string | — | Verdict is before, after or unproven. | | `order[].why` | body | string | — | Why states, in one sentence, what the verdict is resting on. | | `project` | body | string | — | Project is the scope the fold covered. | | `records` | body | patent.PatentProofEntry\[] | — | Records are the entries folded, oldest clock first. | | `records[].authored_by` | body | string | — | AuthoredBy is the validated subject on the record. | | `records[].content_hash` | body | string | — | ContentHash is the server's digest of the recorded content. | | `records[].digest` | body | string | — | Digest is what the fold consumed: content hash and clock together, so two versions of one id with identical content still differ in the fold. | | `records[].id` | body | string | — | ID is the record's stable id. | | `records[].kind` | body | string | — | Kind is idea, implementation, disclosure or approval. | | `records[].recorded_at` | body | string | — | RecordedAt is the server clock at the append. | | `records[].revision` | body | string | — | Revision is original, corrected or retracted. | | `records[].seq` | body | integer (int64) | — | Seq is the append clock value. | | `root` | body | string | — | Root is the fold digest over every record in append order. | | `verdict` | body | string | — | Verdict is the whole answer in one word: supported when every pair is `before`, contested when any is `after`, unproven when any is missing, and empty when there was nothing to fold. | | `verified_at` | body | string | — | VerifiedAt is when this fold was computed. | Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo patent proof ``` **SDK** **.ts** ```ts import { Configuration, PatentApi } from 'hanzoai'; const api = new PatentApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.getPatentProof(); ``` **.py** ```python from hanzoai.cloud import ApiClient, Configuration from hanzoai.cloud.api import PatentApi client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"])) result = PatentApi(client).get_patent_proof() ``` **.go** ```go cfg := hanzoai.NewConfiguration() cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY")) client := hanzoai.NewAPIClient(cfg) resp, _, err := client.PatentAPI.GetPatentProof(context.Background()).Execute() if err != nil { return err } ``` **.rs** ```rust use hanzo_client::apis::{configuration::Configuration, patent_api}; let mut cfg = Configuration::new(); cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok(); let result = patent_api::get_patent_proof(&cfg, Default::default()).await?; ``` **.java** ```java import ai.hanzo.cloud.ApiClient; import ai.hanzo.cloud.api.PatentApi; ApiClient client = new ApiClient(); client.setBearerToken(System.getenv("HANZO_API_KEY")); var result = new PatentApi(client).getPatentProof(); ``` The method above is the one at the current release of the document. `hanzoai@8.5.914` (npm) and `hanzoai@8.5.914` (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. [SDKs →](https://docs.hanzo.ai/docs/sdks) **HTTP** ```bash curl https://api.hanzo.ai/v1/patent/proof \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** Tool `patent`, op `get_patent_proof` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`. ```bash curl -X POST https://api.hanzo.ai/v1/mcp \ -H "Authorization: Bearer $HANZO_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "patent", "arguments": { "op": "get_patent_proof", "input": {} } } }' ``` --- [Patent API](https://docs.hanzo.ai/docs/openapi/patent) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)