Tools · 07 · built here

Schema & entity generator.

Generate clean, valid schema.org JSON-LD for a person or an organization — with a proper sameAs graph. This is the knowledge-graph layer that tells a language model which entity you are, and severs you from everyone else who shares your name.

Built herev0.1 · client-side
Entity type
sameAs — identity graph

LinkedIn · X · Wikipedia · Wikidata · GitHub · Crunchbase · ORCID · your site

knowsAbout — topics
application/ld+json

Paste inside the <head> of the page this entity is the primary subject of. Generated entirely in your browser — nothing you type is uploaded.

§ 01
Why it matters

Models resolve entities, not strings.

A frontier model doesn't just match your name as text — it tries to resolve it to a node in a knowledge graph. Schema.org markup, and the sameAs edges in particular, are how you hand it the right node instead of leaving it to guess between you and your namesakes.

01

Resolution, not retrieval

Before a model can cite you, it has to decide who you are — mapping the string of your name onto an entity with edges to organizations, topics, and other identities. Ambiguous input resolves to the wrong node, or to none.

02

sameAs is the disambiguation layer

Every sameAs URL — LinkedIn, Wikidata, ORCID, GitHub — is a corroborating claim: this is the same entity as that one. A dense, consistent set of edges is what lets a model resolve you confidently instead of hedging.

03

Namesakes are a visibility tax

If three people share your name, an unanchored entity gets averaged across all of them — your credentials, someone else's work, a third person's controversy. A clean graph severs the collision and keeps the citation yours.

04

A canonical entity is a defense

Entity-graph spoofing works by injecting conflicting identity claims. The entity you publish and control — consistent name, @id, and sameAs across every page — is the baseline a model reconciles against. Inconsistency is the vulnerability.

The full argument — how entity resolution works and how to earn it — is in Entity disambiguation for humans. The adversarial side — how a knowledge graph gets spoofed, and why a self-consistent entity is the baseline defense — is in the GEO threat model.

  • One primary entity per page. Mark up the entity a page is actually about. Your home or about page carries the Person / Organization node; don't stamp the same block on every URL and dilute the signal.
  • Give it a stable @id. A canonical @id (e.g. https://yoursite.com/#you) lets every other node — articles, products, breadcrumbs — reference the same entity instead of spawning duplicates. This tool emits a clean standalone node; add the @id when you wire it into a page's graph.
  • sameAs should point at high-trust anchors. Wikidata, Wikipedia, ORCID and official profiles carry more disambiguating weight than a scatter of social links. Use canonical URLs — https, no tracking parameters — and keep them identical everywhere they appear.
  • Consistency beats volume. The same name, title, and sameAs set across your site, your profiles, and third-party mentions is what makes an entity legible. Conflicting values are exactly what make it spoofable.
  • Validate, and remember markup is a claim, not proof. Run the output through Google's Rich Results Test or the schema.org validator. Structured data asserts who you are; the corroborating references off-site are what make a model believe it.
Everything here runs on your device — no field you type leaves the browser. Want the entity graph audited end to end? Book a GEO audit →

Schema is the easy 20%.

The markup takes two minutes. Earning the corroborating references that make a model trust the entity is the actual work — and it's most of what a GEO audit fixes.

Work with me →