Announcing the Context.dev Go SDK

Today we are shipping an official Go SDK for Context.dev.

If you build backend services in Go, you can now use Context.dev without hand-writing request structs, authentication headers, query serialization, and response parsing for every endpoint. Install the package, create a client, and call the same brand intelligence and web context APIs that are already available through our TypeScript, Python, and Ruby SDKs.

The package is available here: github.com/context-dot-dev/context-go-sdk.

Install

go get github.com/context-dot-dev/context-go-sdk

Then create a client with your API key:

package main
 
import (
	"context"
	"fmt"
	"os"
 
	contextdev "github.com/context-dot-dev/context-go-sdk"
	"github.com/context-dot-dev/context-go-sdk/option"
)
 
func main() {
	ctx := context.Background()
	client := contextdev.NewClient(
		option.WithAPIKey(os.Getenv("CONTEXT_DEV_API_KEY")),
	)
 
	brand, err := client.Brand.Get(ctx, contextdev.BrandGetParams{
		Domain: "stripe.com",
	})
	if err != nil {
		panic(err)
	}
 
	fmt.Printf("%+v\n", brand)
}

What you can call from Go

The Go SDK covers the same core Context.dev surface area:

Brand lookup by domain, email, company name, or stock ticker
Transaction enrichment from messy bank statement descriptors
Website screenshots
Styleguide and font extraction
URL-to-Markdown and raw HTML scraping
Image extraction from a page
Sitemap discovery and full-site crawling
AI website queries with structured fields
Product extraction from a domain or product URL
NAICS and SIC classification

In other words, Go services can now fetch company context, brand assets, live website content, and structured AI extraction results with first-party SDK support instead of raw HTTP calls.

A few examples

Retrieve brand data:

brand, err := client.Brand.Get(ctx, contextdev.BrandGetParams{
	Domain: "stripe.com",
})

Scrape a page into Markdown:

page, err := client.Web.WebScrapeMd(ctx, contextdev.WebWebScrapeMdParams{
	URL: "https://stripe.com/pricing",
})

Capture a screenshot:

screenshot, err := client.Web.Screenshot(ctx, contextdev.WebScreenshotParams{
	Domain: contextdev.String("stripe.com"),
})

Crawl a site:

crawl, err := client.Web.WebCrawlMd(ctx, contextdev.WebWebCrawlMdParams{
	URL:      "https://stripe.com",
	MaxPages: contextdev.Int(25),
	MaxDepth: contextdev.Int(2),
})

Query a website with AI:

answer, err := client.AI.AIQuery(ctx, contextdev.AIAIQueryParams{
	Domain: contextdev.String("stripe.com"),
	DataToExtract: []contextdev.AIAIQueryParamsDataToExtract{{
		DatapointName:        "pricing_model",
		DatapointDescription: "How the company prices its main products",
		DatapointType:        "text",
	}},
})

Why this matters

Go is a natural fit for the kinds of systems Context.dev often powers: enrichment pipelines, backend services, data products, fintech workflows, crawler jobs, and AI infrastructure.

Those systems usually care about predictable interfaces, explicit errors, fast startup times, and code that is easy to deploy as a small service. The Go SDK is designed for that style of work. You get typed params, typed responses, standard context.Context support, and the same API key authentication model used across the rest of Context.dev.

Works in the dashboard too

We also updated the developer dashboard so every copyable API example now includes a Go SDK option. If you are testing endpoints in the playground, you can switch the code sample dropdown to Go (SDK) and copy a working Go example for the exact request you configured.

That includes advanced options like cache age, browser wait time, crawl depth, screenshot viewport, AI query datapoints, and transaction matching hints.

Tested endpoint by endpoint

We tested the generated Go samples individually against the official SDK package. Each dashboard sample is compiled in its own temporary Go package with go test ., so the examples are checked as actual Go programs rather than treated as static snippets.

That coverage includes brand retrieval, styleguides, fonts, NAICS, SIC, AI Query, screenshots, image scraping, Markdown scraping, HTML scraping, sitemap crawling, website crawling, product extraction, transaction enrichment, and the onboarding first-call snippet.

Get started

If you already have a Context.dev API key, install the SDK and start with a small brand lookup:

go get github.com/context-dot-dev/context-go-sdk

If you do not have a key yet, create one in the Context.dev dashboard, set CONTEXT_DEV_API_KEY, and run your first request.

We are going to keep expanding the SDKs around the workflows developers actually build: enrichment jobs, AI agents, personalized onboarding, research tools, transaction intelligence, and web context pipelines.

If you build something with the Go SDK, send it our way. We want the Go experience to feel as direct and reliable as the API itself.