The Google Knowledge Graph Search API is a free, read-only endpoint at kgsearch.googleapis.com that lets you query Google’s Knowledge Graph for entities (people, companies, places, creative works) and get back their names, schema.org types, short descriptions, machine IDs and a match score. For brand owners, that makes it the cheapest way to answer a question that shapes your knowledge panel and your visibility in AI answers: does Google think you exist as a thing, or only as a string of words on some web pages?

That distinction sounds academic until a founder searches their own company and gets a knowledge panel for a different firm with a similar name. This guide covers what the API returns, how to call it, how to read the response, the limits Google now attaches, and an audit you can run this week.

What the Google Knowledge Graph Search API actually returns

Hands writing code on a laptop to send a first Knowledge Graph API request

Google launched the API as the successor to the Freebase API, the open database Google acquired and later wound down. Search Engine Land reported at the time that the new API would replace both the Freebase API and the Freebase Suggest Widget. That history still shows up in the data today, which we will get to when we read IDs.

Google lists three intended uses: ranked lists of notable entities, predictive completion in a search box, and annotating content with entities. It does not return relationships. Google says plainly that the API returns individual matching entities rather than graphs of interconnected entities, and points anyone who needs graph data to Wikidata’s data dumps.

You get a flat card per entity, not a web of relationships. The response is JSON-LD and uses schema.org types, which matters because it is the same vocabulary you use in your site’s structured data. When your Organization markup and Google’s stored entity speak the same language, mismatches are easy to spot.

Each result can carry eight fields that the reference documentation defines. The @id is the canonical URI for the entity. The name is the entity’s name. The @type array lists the matching schema.org types, such as Person, Organization or Corporation. The description is a short line (“Singer-songwriter” in Google’s own sample). The image is a picture “to help you identify the entity,” in Google’s words, not a license to republish it. The detailedDescription is a longer passage, which in Google’s sample comes from Wikipedia with a source URL and license attached. The url is the entity’s official website when Google has one. And resultScore is a number indicating how well the entity matched your request constraints.

One sentence in the documentation deserves more attention than it gets: the API is read-only. You cannot submit corrections through it. It is a window, not a door.

How do you make your first request?

You need a Google Cloud project, the Knowledge Graph Search API enabled on it, and an API key. Google’s developer page walks through those prerequisites. Once you have a key, the request is a plain GET against a single method, entities.search, with an empty request body.

Here is the sample request from Google’s own documentation, with your key swapped in where it says API_KEY:

https://kgsearch.googleapis.com/v1/entities:search?query=taylor+swift&key=API_KEY&limit=1&indent=True

Google’s documented output for that call returns Taylor Swift typed as Thing and Person, described as “Singer-songwriter,” with a resultScore of 4850.

The parameters are short enough to learn in one sitting. The query parameter is the literal string you are searching for. The ids parameter lets you look up specific entity IDs instead, and you repeat it to fetch several at once (ids=A&ids=B). The languages parameter takes ISO 639 codes like en or de, which helps when your brand is better known in one market. The types parameter restricts results to schema.org types, so types=Organization filters out the band, the novel and the racehorse that share your company’s name. The prefix parameter turns on initial-substring matching against names and aliases, the feature behind search-box autocomplete. The limit parameter caps the number of results; Google sets the default at 20 and the maximum at 500, and warns that high limits are more likely to time out. And indent simply pretty-prints the JSON.

For brand work, query, ids, types and limit do most of the job, and the Google Knowledge Graph Search API rarely needs more than that.

Read the response like an entity auditor

Person reading lines of code on a screen while auditing an API response

Below is an illustrative shape of a response for a fictional company. It is not real output from Google. It is a mock-up that follows the field structure in Google’s reference documentation, so you know what you are looking at when your own results come back.

{
  "@context": {
    "@vocab": "http://schema.org/",
    "kg": "http://g.co/kg",
    "EntitySearchResult": "goog:EntitySearchResult",
    "resultScore": "goog:resultScore",
    "detailedDescription": "goog:detailedDescription"
  },
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "EntitySearchResult",
      "result": {
        "@id": "kg:/g/11example123",
        "name": "Example Battery Co",
        "@type": ["Organization", "Corporation", "Thing"],
        "description": "Battery manufacturer",
        "url": "https://www.example.com/"
      },
      "resultScore": 312.5
    }
  ]
}

Start with the @id. Strip the kg: prefix and you have the entity’s machine ID, often called a KGMID. Here the history from Freebase pays off. IDs beginning /m/ are, in most cases, legacy Freebase identifiers; SerpApi’s explainer gives Canada (/m/0d060g) as an example. IDs beginning /g/ were minted in the modern Knowledge Graph, like the 2026 FIFA World Cup at /g/1pznmpnqh. A newer company will almost always carry a /g/ ID. Neither prefix is better. What matters is that you have one, that you have only one, and that it points to the right entity.

Write that ID down. You can paste it into a Google search URL as a kgmid parameter (google.com/search?kgmid=/m/02_286 is SerpApi’s New York City example) to try to pull up the matching knowledge panel directly, though SerpApi notes the trick does not always work. You can also hand it back to the API with the ids parameter to check the entity on a schedule.

Next, read the @type array. If your company comes back as only Thing, Google has a weak idea of what you are. If a founder comes back typed as Person with no description, Google knows the name but has not attached a role. Both are fixable, but only once you see them.

Then read description and detailedDescription. When they are missing, Google has no strong third-party description to pull. When they are wrong, the error usually lives upstream in a source you can trace.

Finally, resultScore. Google defines it only as an indicator of how well the entity matched the request constraints. Treat it as a ranking signal inside a single response, not as a brand score you can track across different queries. If your company shows up at position four behind three namesakes with much higher scores, that tells you something about how distinct your name is to Google. It does not tell you how famous you are.

The fine print Google now attaches

Here is where many older tutorials go stale. Google’s developer page now carries a warning in bold terms: the API is not suitable for use as a production-critical service, and your product should not depend critically on it. Google also says it is migrating the API to Cloud Enterprise Knowledge Graph to support enterprise requirements and high-QPS use cases, and that new users should start there.

None of that stops you from using the API for audits. Just do not build a customer-facing feature on it.

On quota, Google’s usage limits page says each project gets up to 100,000 read calls per day at no charge. You can request more through the quotas page in the Google API Console. For a brand checking its own name, a handful of competitors and its leadership team, you will never get near that ceiling.

The Enterprise Knowledge Graph alternative lives in Google Cloud and comes in two editions. The Basic edition queries the public Knowledge Graph through an endpoint shaped like enterpriseknowledgegraph.googleapis.com/v1/projects/PROJECT_ID/locations/global/publicKnowledgeGraphEntities:Search. The Advanced edition adds its own cloudKnowledgeGraphEntities methods. Authentication switches from a simple API key to OAuth access tokens or service accounts. Google’s migration notes flag three response changes worth knowing before you port any script: the Cloud Knowledge Graph MID becomes the primary identifier (with the legacy Google KG MID kept under a googleKgMID property for backward compatibility), a nameLicense property describes licensing rules for the name field, and resultScore is gone. The Advanced edition’s sample responses also expose extra identifiers such as a Wikidata QID and a Google Place ID.

Two more caveats. Google lists the Enterprise Knowledge Graph search documentation as Preview, under pre-GA terms, and its docs give no shutdown date for the legacy kgsearch endpoint as of this writing.

Why does this matter for knowledge panels and AEO?

A knowledge panel is Google’s public rendering of an entity. If the entity does not exist, or exists as the wrong thing, the panel cannot be right. The Google Knowledge Graph Search API is the closest outside view you can get of that record.

The bigger shift is in answer engines. When someone asks ChatGPT, Perplexity, Gemini or Google’s AI Overviews “what is the best battery recycler in Ohio,” the system has to resolve names into things before it can recommend any of them. AI Overviews live inside Google Search, next to the same panels the Knowledge Graph powers. Other assistants build their own understanding, but they draw on many of the same kinds of public sources that feed Google: Wikipedia, Wikidata, news coverage, authoritative directories and your own structured data. That overlap is why one clean entity record tends to help in more than one place.

That gives you a practical rule. If the Knowledge Graph cannot tell your company apart from a namesake, assume at least some AI systems will struggle too. Fix the entity and you improve the odds across several surfaces at once.

There is a press angle most brands miss. Third-party coverage in publications that Google and AI models treat as reliable is one of the inputs that gives an entity a description, a type and a reason to exist. A company with a thin website and no coverage tends to show up in the API, if at all, as a bare name. A company with consistent coverage, a clear Organization schema on its site and matching profiles across trusted sources tends to come back with a type, a description and a URL.

Run the Three-Lookup Entity Audit

One lookup tells you very little. The method I use, which I call the Three-Lookup Entity Audit, runs three different queries and compares them. Each lookup answers a separate question, and the gaps between them are where the problems hide.

Lookup one is the open name query. Search your brand name with no type filter and limit=20. The question it answers: who else owns this name in Google’s mind? Count how many entities come back above yours and what they are. If you are a fintech called Atlas and you land behind a mythological figure, a book of maps and a rocket, you now know why your panel is unstable. Record your position and your @id.

Lookup two is the typed query. Run the same name with types=Organization (or types=Person for a founder). The question: when Google knows what kind of thing it is looking for, does it find you? If you jump to the top here but sat at position nine in lookup one, the entity exists and is typed correctly, and your issue is name collision. If you still do not appear, your problem is more basic. Google either has no Organization entity for you or has typed you as something else.

Lookup three is the ID query. Take the @id from whichever lookup found you and query it directly with ids=. The question: what does Google hold on this exact entity, with no ranking noise? Compare the name, types, description and url against the facts on your own site and in your Organization schema. Every mismatch is a task. A missing url means Google has not connected the entity to your domain. A wrong description means an upstream source is wrong. Two different IDs for what should be one company means you have a duplicate entity, which tends to cause the flickering panels people complain about.

Say you run a battery startup. Lookup one returns you at position six behind a 1990s band. Lookup two returns you first, typed Organization, but with no description. Lookup three shows the url field points to an old domain you sold in 2022. That is a clear, ordered to-do list: fix the domain association first, then build the third-party descriptions, then work on name distinctiveness. Repeat the three lookups every quarter to see whether the record moves.

Your next step: run it on Monday

Here is the concrete next step. Set up a Google Cloud project, enable the Knowledge Graph Search API, create a restricted API key, and run the Three-Lookup Entity Audit on three entities: your company, your founder or CEO, and your flagship product. That is nine requests, well inside the free quota.

Log the results in a sheet, then check your site’s Organization and Person schema against what came back. Make sure your sameAs links point to the profiles you want Google to connect, and that your legal name, brand name and domain match everywhere you control them.

If lookup three reveals a missing or weak description, that is rarely a markup problem. It usually means the outside world has not yet written about you in the places Google and AI systems trust. That part takes earned coverage, and it is the part we spend most of our time on at Instant Press. If you want a quick read on where you stand, our AEO rating is a good place to start. Either way, run the audit first. You cannot fix an entity you have never looked at.