Create entity

Resolves the complete state of one entity at a point: its type, its holding properties and edges in both directions, its kinship scorecard and the expired statements it no longer holds.

POST /v1/graph/entity

Graph → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/graph/entity`
Method	`POST`
Operation	`graphEntity`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Resolves the complete state of one entity at a point: its type, its holding properties and edges in both directions, its kinship scorecard and the expired statements it no longer holds.

Each (entity, relation) pair is settled by the same Resolve rule as graphResolve. Statements begun by the point that lost to a retraction, an until or a newer value are returned in expired rather than discarded.

Time: as_of is the instant of the world asked about and as_known how much this plane had heard by then; either absent is now.

Request

3 fields, body application/json (required).

Field	In	Type	Required	Description
`as_known`	body	string	—	AsKnown is how much this plane had heard, RFC 3339: the answer as it would have been given then.
`as_of`	body	string	—	AsOf is the instant of the world to answer about, RFC 3339: what held then.
`entity`	body	string	yes	Entity is the entity key to resolve.

Response

Status	Body	Meaning
`200`	graph.graphEntityOut	ok
`default`	problem-details	refused

200 body — 97 fields.

Field	In	Type	Always	Description
`as_known`	body	string	—	AsKnown is the knowledge instant this state was resolved at, RFC 3339.
`as_of`	body	string	—	AsOf is the valid instant this state was resolved at, RFC 3339.
`entity`	body	string	—	Entity is the folded entity key the question named.
`expired`	body	graph.wireFact[]	—	Expired is every statement about the entity that was known by AsKnown and begun by AsOf but no longer holds at AsOf because its until passed, a retraction ended it, or a later statement superseded it.
`expired[].at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`expired[].by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`expired[].confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`expired[].entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`expired[].evidence`	body	string	—	Evidence points at the record the claim came from.
`expired[].id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`expired[].knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`expired[].names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`expired[].relation`	body	string	—	Relation is what was asserted of it.
`expired[].seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`expired[].source`	body	string	—	Source names who asserted, as the caller gave it.
`expired[].until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`expired[].value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`incoming`	body	graph.wireFact[]	—	Incoming is every in-force edge pointing at the entity at the point, ordered by source entity and relation key.
`incoming[].at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`incoming[].by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`incoming[].confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`incoming[].entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`incoming[].evidence`	body	string	—	Evidence points at the record the claim came from.
`incoming[].id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`incoming[].knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`incoming[].names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`incoming[].relation`	body	string	—	Relation is what was asserted of it.
`incoming[].seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`incoming[].source`	body	string	—	Source names who asserted, as the caller gave it.
`incoming[].until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`incoming[].value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`known`	body	boolean	—	Known is true when at least one property, outgoing edge, incoming edge or expired statement was found for the entity.
`outgoing`	body	graph.wireFact[]	—	Outgoing is every in-force edge asserted about the entity at the point, ordered by relation key and then winner order.
`outgoing[].at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`outgoing[].by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`outgoing[].confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`outgoing[].entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`outgoing[].evidence`	body	string	—	Evidence points at the record the claim came from.
`outgoing[].id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`outgoing[].knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`outgoing[].names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`outgoing[].relation`	body	string	—	Relation is what was asserted of it.
`outgoing[].seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`outgoing[].source`	body	string	—	Source names who asserted, as the caller gave it.
`outgoing[].until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`outgoing[].value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`properties`	body	graph.graphEntityProperty[]	—	Properties is every in-force scalar property of the entity at the point, ordered by relation key.
`properties[].conflicts`	body	graph.wireFact[]	—	Conflicts is every weaker account of the winner's moment that names a different value, strongest first.
`properties[].conflicts[].at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`properties[].conflicts[].by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`properties[].conflicts[].confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`properties[].conflicts[].entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`properties[].conflicts[].evidence`	body	string	—	Evidence points at the record the claim came from.
`properties[].conflicts[].id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`properties[].conflicts[].knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`properties[].conflicts[].names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`properties[].conflicts[].relation`	body	string	—	Relation is what was asserted of it.
`properties[].conflicts[].seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`properties[].conflicts[].source`	body	string	—	Source names who asserted, as the caller gave it.
`properties[].conflicts[].until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`properties[].conflicts[].value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`properties[].contested`	body	boolean	—	Contested is true exactly when Conflicts is not empty.
`properties[].relation`	body	string	—	Relation is the scalar relation's key.
`properties[].value`	body	string	—	Value is the winning scalar value holding at the point.
`properties[].winner`	body	graph.wireFact	—
`properties[].winner.at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`properties[].winner.by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`properties[].winner.confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`properties[].winner.entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`properties[].winner.evidence`	body	string	—	Evidence points at the record the claim came from.
`properties[].winner.id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`properties[].winner.knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`properties[].winner.names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`properties[].winner.relation`	body	string	—	Relation is what was asserted of it.
`properties[].winner.seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`properties[].winner.source`	body	string	—	Source names who asserted, as the caller gave it.
`properties[].winner.until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`properties[].winner.value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`scorecard`	body	graph.graphKinshipScore[]	—	Scorecard is the kinship and closeness scores holding on the entity, highest score first.
`scorecard[].assertion`	body	graph.wireFact	—
`scorecard[].assertion.at`	body	string	—	At is when the thing was so, RFC 3339, as the asserter gave it.
`scorecard[].assertion.by`	body	string	—	By is the identity that filed it — `owner` or `owner/user` — stamped from the validated principal at the write, never from the body.
`scorecard[].assertion.confidence`	body	number (double)	—	Confidence in [0,1] as the asserter gave it; absent is 0.
`scorecard[].assertion.entity`	body	string	—	Entity is the thing described, in the organization's own namespace.
`scorecard[].assertion.evidence`	body	string	—	Evidence points at the record the claim came from.
`scorecard[].assertion.id`	body	string	—	ID is the assertion's content address, minted by the server from what was asserted.
`scorecard[].assertion.knowable`	body	string	—	Knowable is the first instant this plane could have answered with the assertion, RFC 3339: the later of Seen and the server's clock at the write.
`scorecard[].assertion.names`	body	boolean	—	Names true means the assertion is an edge and Value is an entity.
`scorecard[].assertion.relation`	body	string	—	Relation is what was asserted of it.
`scorecard[].assertion.seen`	body	string	—	Seen is when the asserter says it became knowable, RFC 3339.
`scorecard[].assertion.source`	body	string	—	Source names who asserted, as the caller gave it.
`scorecard[].assertion.until`	body	string	—	Until is when the thing stopped being so, RFC 3339, as the asserter gave it.
`scorecard[].assertion.value`	body	string	—	Value is what the relation points at: another entity's key when Names is true, otherwise a scalar.
`scorecard[].relationship`	body	string	—	Relationship is the scorecard column, such as mother, father, partner, family or familyAndFriends.
`scorecard[].score`	body	number (double)	—	Score is the classifier probability in [0,1].
`truncated`	body	boolean	—	Truncated says the read of outgoing or incoming assertions hit the walk ceiling.
`type`	body	string	—	Type is the winning `type` of the entity at the point.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo graph entity --entity <entity>

.ts

.py

.go

.rs

.java

import { Configuration, GraphApi } from 'hanzoai';

const api = new GraphApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.graphEntity({ entity: "<entity>" });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import GraphApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = GraphApi(client).graph_entity(entity="<entity>")

cfg := hanzoai.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := hanzoai.NewAPIClient(cfg)

resp, _, err := client.GraphAPI.GraphEntity(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_client::apis::{configuration::Configuration, graph_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = graph_api::graph_entity(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.GraphApi;

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new GraphApi(client).graphEntity();

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 -X POST https://api.hanzo.ai/v1/graph/entity \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "entity": "<entity>"
     }'

Tool graph, op graphEntity — 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": "graph",
         "arguments": {
           "op": "graphEntity",
           "input": {
             "entity": "<entity>"
           }
         }
       }
     }'

Graph 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.

PreviousCreate diff NextCreate erase