---
title: "pkg.go.dev ganha API oficial para módulos Go"
url: "https://golang.com.br/novidades/pkg-go-dev-api-oficial/"
markdown_url: "https://golang.com.br/novidades/pkg-go-dev-api-oficial.MD"
description: "API oficial do pkg.go.dev permite consultar módulos, pacotes, versões, símbolos e vulnerabilidades Go sem depender de scraping."
date: "2026-05-25"
author: "Go Brasil"
---

# pkg.go.dev ganha API oficial para módulos Go

API oficial do pkg.go.dev permite consultar módulos, pacotes, versões, símbolos e vulnerabilidades Go sem depender de scraping.


TL;DR: o time Go anunciou uma **API oficial do pkg.go.dev** para consultar metadados de módulos e pacotes publicados no ecossistema Go. Em vez de fazer scraping da interface web, ferramentas agora podem usar endpoints JSON em `https://pkg.go.dev/v1beta` para buscar versões, pacotes, símbolos, dependentes e vulnerabilidades. A API ainda está em `v1beta`, mas já é um passo importante para IDEs, automações de CI, inventários de dependências e assistentes de código que precisam de contexto confiável sobre bibliotecas Go.

## O que foi anunciado

O `pkg.go.dev` já era a referência diária para ler documentação de pacotes, checar versões e confirmar import paths. A novidade é que essa informação agora tem uma interface de serviço documentada, pensada para uso programático.

O anúncio oficial descreve a API como uma forma de consultar metadados sobre módulos Go publicados. Isso inclui o tipo de dado que antes muita ferramenta tentava obter parseando HTML: pacote, módulo, lista de versões, pacotes dentro de um módulo, símbolos exportados, quem importa determinado pacote e vulnerabilidades associadas.

A base atual é:

```text
https://pkg.go.dev/v1beta
```

Todos os endpoints documentados são `GET` e retornam JSON. A escolha por uma API sem estado e cacheável é importante: clientes simples conseguem chamar os endpoints diretamente, enquanto ferramentas maiores podem armazenar respostas e reduzir tráfego sem depender da estrutura visual do site.

## O que dá para consultar

A documentação lista endpoints para as consultas mais comuns do dia a dia de tooling:

```text
GET /v1beta/package/{path}
GET /v1beta/module/{path}
GET /v1beta/versions/{path}
GET /v1beta/packages/{path}
GET /v1beta/search?q={query}
GET /v1beta/symbols/{path}
GET /v1beta/imported-by/{path}
GET /v1beta/vulns/{path}
```

Na prática, isso cobre três grupos de uso. O primeiro é descoberta: buscar pacotes, listar módulos e encontrar versões. O segundo é entendimento de API: consultar símbolos declarados, documentação e metadados de pacote. O terceiro é operação: verificar vulnerabilidades e estimar impacto observando pacotes que importam outro pacote.

Um exemplo simples de chamada:

```bash
curl -L https://pkg.go.dev/v1beta/package/github.com/google/go-cmp/cmp
```

A resposta inclui campos como caminho do módulo, versão, pacote, nome, sinopse, se aquela versão é a mais recente, se pertence à biblioteca padrão e se o conteúdo é redistribuível. Para consultas de módulo, a API também pode retornar repositório, conteúdo de `go.mod`, README e licenças quando esses campos são pedidos por parâmetro.

## Por que isso importa para quem trabalha com Go

Para um desenvolvedor escrevendo uma API Go comum, a mudança não altera o código de produção. O impacto aparece nas ferramentas que cercam o projeto.

Um time pode, por exemplo, montar uma verificação interna que consulta versões de módulos usados em vários repositórios, cruza com vulnerabilidades do ecossistema Go e gera uma fila de atualização. Uma extensão de editor pode enriquecer resultados de busca com sinopse e símbolos. Um robô de documentação pode resolver import paths e apontar para pacotes corretos sem raspar páginas HTML. E ferramentas de IA podem buscar contexto de pacote com mais precisão, em vez de depender de texto copiado de fontes inconsistentes.

Esse ponto conversa com uma dor recorrente no ecossistema: descobrir bibliotecas boas e mantidas não é só “buscar no Google”. Na pesquisa de desenvolvedores Go, sinais de qualidade no `pkg.go.dev` aparecem como um pedido comum da comunidade. Uma API oficial não resolve sozinha o problema de curadoria, mas dá uma base melhor para construir painéis, checks e fluxos de revisão.

Se você está começando, o uso manual do site continua sendo o caminho principal. O guia de [documentação Go em português](/aprenda/documentacao-go/) explica como usar `pkg.go.dev`, `go doc` e a documentação oficial no dia a dia. A API é mais interessante quando você quer automatizar esse conhecimento.

## Detalhes que merecem atenção

A API está sob `/v1beta`, então clientes devem tratar o formato como novo e acompanhar mudanças antes de depender dela como contrato definitivo. O post do Go fala em caminhar para um `v1` depois de feedback e estabilidade.

Também há diferenças deliberadas em relação à interface web. Quando um caminho de pacote é ambíguo, a API pode retornar candidatos e pedir que o cliente seja mais específico usando o parâmetro `module`. A UI do `pkg.go.dev` costuma resolver isso escolhendo o módulo mais longo; a API prefere precisão a conveniência. Para ferramenta automatizada, isso é uma boa decisão: melhor obrigar desambiguação do que retornar um pacote errado silenciosamente.

Parâmetros como `version`, `goos`, `goarch`, `doc`, `examples`, `imports`, `licenses`, `limit`, `token` e `filter` aparecem em endpoints específicos. Para `version`, a documentação aceita versões semânticas, `latest` e os branches `main` ou `master`. Para paginação, o cliente deve repetir a mesma requisição adicionando apenas o `token` retornado.

Um cuidado prático: filtros são expressões regulares e precisam ser codificados na URL. Em Go, use `url.QueryEscape` antes de montar a query string manualmente.

```go
q := url.QueryEscape("^github.com/.*/uuid")
fmt.Println("filter=" + q)
```

O anúncio não menciona autenticação nem limites de taxa. Para uso sério em CI ou serviços internos, vale implementar cache, timeout e tratamento claro de erros em vez de assumir disponibilidade infinita.

## Como experimentar

O jeito mais direto é usar `curl` com `jq` e inspecionar as respostas. Para explorar via ferramenta de referência, o post apresenta o `pkgsite-cli`:

```bash
go install golang.org/x/pkgsite/cmd/internal/pkgsite-cli@latest
pkgsite-cli search "uuid"
pkgsite-cli package --symbols github.com/google/go-cmp/cmp
```

O próprio anúncio avisa que a interface de linha de comando ainda pode mudar, então trate o comando como demonstração e referência, não como contrato estável. Para integrações, prefira ler a documentação da API e a especificação OpenAPI.

## Saiba mais

- [Anúncio: Introducing the pkg.go.dev API](https://go.dev/blog/pkgsite-api)
- [Documentação da API do pkg.go.dev](https://pkg.go.dev/api)
- [Especificação OpenAPI](https://pkg.go.dev/v1beta/openapi.yaml)
- [Documentação Go em português](/aprenda/documentacao-go/)