List proof

Folds the caller's record set and answers the ordering question over it.

GET /v1/patent/proof

Patent → · All API references → · Get started →

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.

Examples

CLI

SDK

HTTP

MCP

hanzo patent proof

.ts

.py

.go

.rs

.java

import { Configuration, PatentApi } from 'hanzoai';

const api = new PatentApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getPatentProof();

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()

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
}

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?;

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. [email protected] (npm) and [email protected] (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 →

curl https://api.hanzo.ai/v1/patent/proof \
  -H "Authorization: Bearer $HANZO_API_KEY"

Tool patent, op get_patent_proof — POST the JSON-RPC envelope to https://api.hanzo.ai/v1/mcp.

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 · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousList implementations NextList timeline