What Is a KGMID? Google's Entity IDs and How to Find Yours

By Cory Maki · Aug 18, 2026

Every person, brand, and product Google recognizes has a private identifier attached to it — a string like /g/11b7lsr1sn or /m/0d060g. It isn't your domain, your Google Business Profile, or your Search Console property. It's a KGMID: the Knowledge Graph Machine ID Google uses internally to distinguish your entity from every other thing with a similar name. Most founders never see it, and that's a problem, because the KGMID is the anchor Google attaches your facts to.

This is a reference post, not a schema tutorial. My goal is narrow: explain exactly what a KGMID is, show you three reliable ways to locate yours, and make the case for why this identifier matters more in AI search than it did in classic SEO. Once you have your KGMID in hand, the next move is wiring it into your markup — and I cover that separately in how to connect entities with schema markup for the Knowledge Graph. Treat this as the prerequisite.

A KGMID is Google's unique identifier for a single named entity

A KGMID (Knowledge Graph Machine ID, also written kgmid or KGID) is a unique identifier Google assigns to each entity in its Knowledge Graph. <mark>The Knowledge Graph Search API returns this value as the entity's id field, and it typically appears as kg:/m/ or /g/ followed by a short string.</mark> The function is disambiguation: <mark>a KGMID represents a specific named entity and helps Google distinguish between entities with similar or the same name.</mark>

The analogy people reach for is an ISBN for books or a Social Security number for a person — a stable identifier that isn't meant to be human-readable. That framing is roughly right. <mark>Every person, place, or thing Google can identify has a Knowledge Graph ID, and it works a bit like an ISBN for books, but not restricted to any category and usually not something a person would ever directly read.</mark>

Here's the practical consequence. When your brand shares a name with anything else — another company, a person, a movie character — Google needs to decide which entity a given fact belongs to. <mark>The identifier is how Google internally distinguishes, say, Dennis Yu the marketing expert from Dennis Yu the dentist, or any other person with the same name.</mark> Applying the right signal to the wrong entity teaches Google nothing useful about you.

/m/ vs /g/: why the prefix tells you the entity's age

The prefix isn't cosmetic. It records where the entity came from. <mark>The Knowledge Graph is effectively two databases: the legacy list from Freebase, where items usually carry an /m/ prefix, and the modern Knowledge Graph, where items carry a /g/ prefix — which is why older topics tend to start with /m/.</mark>

That split is a historical artifact. <mark>Google acquired Metaweb, which powered Freebase, in 2010, and in 2014 decided to migrate Freebase content to Wikidata, winding the service down through 2015.</mark> <mark>When Freebase was turned read-only on March 31, 2015, it held more than 3 billion facts about almost 50 million entities.</mark> So if your entity ID starts with /m/, Google has understood you since the Freebase era; a /g/ ID means the entity was minted in the modern Knowledge Graph. For most SaaS brands founded in the last decade, expect a /g/ prefix.

One more distinction worth knowing: the Cloud Knowledge Graph now issues its own MID format. <mark>Google's lookup API works for both the newer Cloud Knowledge Graph MID, which starts with c-, and the classic Google Knowledge Graph MID, which starts with /m.</mark> For GEO purposes you care about the public Knowledge Graph entity, not the enterprise reconciliation IDs.

You can find your KGMID three ways, from easiest to most technical

There's no dashboard that hands you your KGMID. You extract it. Three methods cover almost every case.

Method 1: the Knowledge Panel Share button

This is the fastest route and the one I use first. <mark>The easiest way to find the KGMID is to use the Share feature in the Knowledge Panel — every Knowledge Panel in the Google SERP contains a KGMID.</mark> Search your brand, open the three-dot or burger menu on the panel, and click Share. <mark>The share URL redirects to a URL that looks like https://www.google.com/search?kgmid=/g/11p187zfbt — look for the /g/ or /m/ sequence, and the string after it is your KGMID.</mark>

One caution that saves real time: <mark>make sure you're looking at the correct Knowledge Panel for the entity you want, because different entities can have similar or identical names.</mark> If you don't have a panel yet, this method won't work — and you'll want the realistic path to getting a Google Knowledge Panel first. You can check current status fast with my free Knowledge Panel checker.

Method 2: page source and the claim flow

If the Share button is missing or you want to confirm, go to the source. <mark>With a Knowledge Panel on screen, right-click and view page source, then search for /g/ or /m/ — the correct one sits next to a null,\x22 sequence, and the entity name appears in the following field.</mark> There's also a claim-flow trick: <mark>clicking "Claim this Knowledge Panel" redirects you to a URL that contains the Knowledge Graph ID directly, such as /g/11kgg0l8s8.</mark> Claiming, incidentally, is the step that converts "Google found you" into "you control your story" — I walk through the how to get a Knowledge Panel path for that.

Method 3: the Knowledge Graph Search API

The most rigorous method queries Google directly. <mark>The Knowledge Graph Search API lets you search for entities using keywords, IDs, and entity types, returning structured data in JSON-LD format following schema.org standards.</mark> A basic request is a single HTTP GET to https://kgsearch.googleapis.com/v1/entities:search with your query and an API key. Read two fields carefully. <mark>The id field is the MID; the resultScore is a confidence score representing Google's confidence that the returned entity is the best match for your query — the higher the score, the stronger the match.</mark>

The API has a hard limit you should design around: <mark>it returns only individual matching entities, not graphs of interconnected entities — for the latter, Google recommends Wikidata data dumps instead.</mark> And not every KGMID lives in the main graph. <mark>The API only returns entities in Google's main Knowledge Graph; verticals like Google Books, Podcasts, and Business Profile generate their own kgmids that don't necessarily sit in the main graph.</mark> If you have a KGMID but the API returns nothing, that's usually why. Free tools like Kalicube's reverse-lookup explorer wrap the same API if you'd rather not provision a key.

The KGMID is where entity disambiguation happens — which is why it matters for AI search

A KGMID itself doesn't rank anything. <mark>The identifier doesn't directly enhance a Knowledge Panel, but it enables efficient analysis, tracking, and updating of the data associated with a specific entity in the Knowledge Graph.</mark> Its value is precision. It tells you which bucket Google is pouring your facts into.

That precision is the whole game in AI search. When Google's AI Overviews, Gemini, and other engines answer a question about your category, they resolve entities before they generate text — deciding which "Acme" the query means, then pulling facts attached to that entity. If Google has split your presence across two IDs, or attached your facts to the wrong one, the model inherits that confusion. <mark>When a brand is inconsistent, Google gets confused and can assign multiple KGMIDs to the same brand, which then requires consolidating the facts and merging the panels.</mark> Two IDs means your authority is diluted across both.

This is the connective tissue between the KGMID and everything else in entity strategy. Knowing your ID lets you verify that your Organization schema, your sameAs links, and your Wikidata entry all point at one recognized entity rather than fragmenting across near-duplicates. That's precisely the discipline I lay out in building your entity with schema and the Knowledge Graph for SaaS, and it's downstream of the broader consistency requirement I argue for in why your facts must match everywhere for AI search. Entity clarity now drives AI citations more directly than page rankings do — a shift I unpack in the full GEO guide.

So treat the KGMID as a diagnostic checkpoint, not a growth lever. Find it, confirm it points at the right entity, confirm it's the only one, and confirm the confidence score is climbing. Then use it to bind your schema to that specific node — which is exactly the step covered in how to connect entities with schema markup. The identifier is the reference point that makes the rest of your entity work land where you intend it to.