Google Developer Knowledge API: How It Returns Docs as Markdown, Batch Limits, and Pricing Status

Bottom line: Google’s Developer Knowledge API, announced October 7, 2026, returns developer documentation as Markdown through gcloud, an agent skill, and client libraries. BatchGetDocuments accepts up to 20 documents per call, and the announcement does not list a price.

The call that fetches a whole documentation page is the expensive one, and Google’s own install note tells you not to start there. Christina Gonzalez, in the Oct. 7 post on the Google Developers Blog, describes the Developer Knowledge API as the programmatic source for docs on Google Cloud, Firebase, Android, and more. The agent skill she points at is explicit about order. Inspect chunks with searchDocumentChunks before you pull a full Markdown page with documents.get, or ask answerQuery for a grounded answer instead. If you wire an agent to download every page the search touches, you have rebuilt the scraping habit the post says this API is supposed to replace, and you have done it with an official client.

We already wrote a local runtime that is not a Google doc store in Antigravity and Gemma 4 on your GPU. We already wrote an installer whose second step was not the one the README implied in OpenShell and Sentry. We already wrote an endpoint that was a preview and then a beta in the Decisions API piece. This one is a documentation API with commands printed in the announcement. The post links a quickstart.

What the Developer Knowledge API says it returns

Gonzalez calls it Google’s official source of truth for that documentation, aimed at agents, IDE extensions, and automated workflows. The replacement target is brittle scraping and stale training cutoffs. The payload is structured, and the format she names is Markdown. Search can be semantic or keyword. Documents are chunked. There is a grounded Q&A path. The index is updated frequently so retrieval stays predictable and the lag between an upstream doc change and agent access stays small. She does not print the lag in minutes.

There is no price in the post. There is no quota. There is no list of which Android pages are in the index and which are not. “Google Cloud, Firebase, Android, and more” is the scope sentence. “And more” is not a catalog. If your agent needs a product that is not in those three names, run a chunk search for a page you know exists before you promise the index covers it. A failed search is a fact. A successful search for Firestore does not prove the index has the page you wanted for a different product.

Four surfaces ship in the same announcement. The gcloud CLI. An official agent skill. API Explorer. Client libraries. Gonzalez says you can work from a terminal, from a prompt to an agent, from an interactive request, or from production code. Those are interfaces onto one index, not four indexes. A chunk you retrieve in gcloud and a chunk you retrieve in the Python client should be the same documentation. The post does not show a side-by-side test.

The gcloud commands, in the order the post prints them

The CLI surface is pre-installed in Cloud Shell. On a normal Google Cloud SDK install it works on Linux, macOS, and Windows without an extra plugin. That is the setup claim. The post then points at a gcloud quickstart for getting started. The commands that are actually in the Oct. 7 post are enough to see the shape.

Grounded answer, from the terminal:

gcloud developer-knowledge answer-query --query="How do I create a BigQuery dataset?"

Chunk search:

gcloud developer-knowledge documents search-chunks --query="Firestore transactions"

One document, by the resource name the post uses in the example:

gcloud developer-knowledge documents describe "documents/docs.cloud.google.com/storage/docs/creating-buckets"

An error file, passed as the query:

gcloud developer-knowledge answer-query --query="$(cat error.txt)"

Read that last one before you put it in a script. The shell expands $(cat error.txt) before gcloud sees it. A stack trace with quotes, backticks, or a multi-megabyte dump becomes the query string. The post shows the pattern as a troubleshooting trick. It does not show a length limit.

The describe example is the most useful line in the set, and it is easy to skip because it looks like a path. The argument is not a URL you paste from a browser. It is a resource name: documents/ plus a host and a doc path, in the example documents/docs.cloud.google.com/storage/docs/creating-buckets. If your chunk search returns a parent name, that parent name is what you hand to the get or describe call. Do not reconstruct it by gluing https:// back on. The post’s example has no scheme and no query string.

answer-query and documents search-chunks take a --query flag in the printed lines. documents describe takes the resource name as a positional argument in the printed line. If a later reference page has a project flag or a format flag, that page can add it. This tutorial stops where the announcement stops.

Cloud Shell is the path with the least install work, because the component is already there. A laptop SDK is the path the post also claims, with no extra plugin.

Search chunks before you fetch the page

The skill install is one command, printed in the post:

npx skills add google/skills --skill retrieving-developer-knowledge

That pulls the skill from google/skills, path given as skills/developers/retrieving-developer-knowledge on GitHub. The skill’s job, as Gonzalez describes it, is to tell the assistant how to use the Developer Knowledge MCP server, or to fall back to the REST API with curl. Compatibility she names: Google Antigravity, Claude Code, Cursor, GitHub Copilot, and custom agent frameworks. Naming a client is not the same as a tested matrix with versions.

The retrieval order is the part worth enforcing even if you never install the skill. searchDocumentChunks first. Then documents.get if you need the full Markdown. Or answerQuery if you want the grounded answer and not the page. The stated reason is token use. A chunk is smaller than a page. An agent that fetches every parent document for every chunk will fill the context window with navigation chrome and repeated headers. The post calls this optimized token and context usage. It also calls the grounding effect a reduction in hallucinations from stale cutoffs. Both claims are Google’s. A chunk that is wrong will still be wrong. Official Markdown is a better source than a model’s memory of a 2024 doc. It is not a proof that the answer endpoint summarized the chunk faithfully. If the decision matters, read the chunk, not only the answer.

Auth is the step the post names and does not walk. Application Default Credentials, or an API key, with a pointer to a quickstart anchor and to a page titled along the lines of connecting the MCP server. Those may be different credential stories. ADC on a laptop is not automatically the key a curl fallback wants. If you mix them, follow the page the post links for the surface you are actually calling. Do not assume the Cloud Shell login covers a curl script on a CI runner.

Antigravity is on the compatibility list. That does not make this API a local model host. The earlier piece on this site was about running Gemma 4 on a GPU through a different SDK. This skill is a retrieval policy for Google’s docs. You can point an Antigravity session at it, according to the post. You should not expect the skill to download a model, and you should not expect a local Gemma process to gain this index unless you wire the tool. The post does not show that wiring. It shows npx skills add.

The Python example, and the calls it does not make

The client libraries Gonzalez lists are C#, Go, Java, Node.js and TypeScript, PHP, Python, and Ruby. The methods she names across them are AnswerQuery, SearchDocumentChunks, GetDocument, and BatchGetDocuments. The batch method retrieves up to 20 documents in one call. That 20 is the only numeric limit in the post. She also says the libraries support Application Default Credentials, automatic retries, and structured citation tracking. “Support” is not a sample of the retry policy.

The Python sample in the post is a function that searches chunks for a product’s release notes. This is the shape, as printed:

from google.cloud import developer_knowledge_v1

def FetchMyProductReleaseNotes(my_product_name: str) -> str:
    my_api_client = developer_knowledge_v1.DeveloperKnowledgeClient()
    my_search_query = f"{my_product_name} latest release notes"
    my_request = developer_knowledge_v1.SearchDocumentChunksRequest(
        query=my_search_query,
    )
    my_response = my_api_client.search_document_chunks(request=my_request)
    my_release_notes = [my_chunk.text for my_chunk in my_response.chunks]
    return "\n".join(my_release_notes)

The snippet constructs a client with no project, no key, and no endpoint. That means the example is relying on whatever the library does by default, which the surrounding prose ties to Application Default Credentials. The post does not show the failure.

The function returns chunk text joined by newlines. It does not call GetDocument. It does not call answerQuery. It does not read a parent field. If you need the full page, this sample is the wrong function. It is the first step the skill describes, and only the first step. A release-notes query can return several chunks from several pages. Joining .text drops the parent name that you would need for the follow-up get. If you are writing the agent for real, keep the parent alongside the text. The post’s prose says the chunk search is how you decide which page to fetch. The sample, as printed, throws that decision away and keeps the text.

BatchGetDocuments is the call you use when you already have up to 20 document names and you want them in one round trip. It is not a search. The sample never reaches it. A loop that calls GetDocument once per chunk parent will work and will ignore the batch method the post bothered to name. If you have 21 parents, the 20 cap means two calls, not one. The post does not say what the API returns if you send 21. Split the list.

API Explorer is the zero-code door. Gonzalez says you can test the core endpoints there, and the post includes an image of a draft diagram. Use Explorer if you want to see the response shape before you commit to a client. Do not transcribe a diagram from memory into a production URL.

What not to assume on a first integration

Do not assume a price, a free tier, or a quota. None of them is in the Oct. 7 post. A tutorial that invents “1,000 queries a day” is how a build fails in a review. Call the method you need, watch the error the client actually raises, and treat that error as the limit until a pricing page you have opened says otherwise.

The skill exists because Google wants the model on fresh Markdown. The answer is a generation grounded in that Markdown, in the post’s wording. Grounded is not the same as quoted. If you are filling a runbook, store the chunk and the parent name. If you are answering a developer in a terminal, answer-query is the command the post leads with, and it is the right command for that desk.

A query is still a string you send to Google. A customer log may have secrets in it. The post frames the pattern as troubleshooting. It does not frame it as a log pipeline. Those are different trust boundaries.

Do not confuse this index with EmbeddingGemma 2, which the same blog shipped a developer guide for on Oct. 6. That guide is a model you can run toward the edge. This API is a remote documentation index. Same week, same blog, different artifact. An agent can use both. It should not use the Gemma guide as the manual for gcloud developer-knowledge.

The next step in Gonzalez’s own close is small. If gcloud is already on the machine, run answer-query against a page you already know, such as the BigQuery example, and see whether the answer matches the doc you remember. If gcloud is not on the machine, install the skill and ask the assistant for the same page. If the chunk parent comes back as a documents/... name, you have the handle the describe example uses. If it comes back as something else, believe the response, not the example string. The example is one storage doc. It is not a schema for every parent name in the index.

What this means for you

For a first integration, search for relevant chunks before fetching full documents, batch requests in groups of 20 or fewer, and check the Google Cloud console for quota and billing details since none were published in the announcement. See also Google’s gcloud CLI documentation for setup.