Go AI Visibility API

Query the raw answers ChatGPT, Perplexity, Google AI Overviews, Google AI Mode, Copilot and Gemini actually return — from Go, with nothing beyond net/http and encoding/json. No chromedp, no rod, no headless Chrome to orchestrate: one POST, and the answer text, citations and sources decode into typed structs your goroutines can fan out over.

Call the AI Visibility API from Go

POST to https://api.agentgeo.org/v1/fetches with your ag_live_ key as a bearer token and the engines you want in the surfaces array. The whole integration is standard library — net/http for the call, encoding/json for decoding into three structs you define once and own. (Want to see the payload before writing code? The raw answer playground runs a query in the browser, no signup.)

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
)

type Source struct {
    Title    string `json:"title"`
    URL      string `json:"url"`
    Position int    `json:"position"`
}

type Answer struct {
    SurfaceKey string   `json:"surfaceKey"`
    AnswerText string   `json:"answerText"`
    Sources    []Source `json:"sources"`
}

type FetchRun struct {
    ID               string   `json:"id"`
    Query            string   `json:"query"`
    Surfaces         []string `json:"surfaces"`
    Status           string   `json:"status"`
    RecordsDelivered int      `json:"recordsDelivered"`
    CreditsCharged   int      `json:"creditsCharged"`
    Answers          []Answer `json:"answers"`
}

// The API waits up to 180s on slow surfaces — keep the client above that.
var client = &http.Client{Timeout: 200 * time.Second}

func fetchRun(query string, surfaces ...string) (*FetchRun, error) {
    body, err := json.Marshal(map[string]any{"query": query, "surfaces": surfaces})
    if err != nil {
        return nil, err
    }
    req, err := http.NewRequest(http.MethodPost, "https://api.agentgeo.org/v1/fetches", bytes.NewReader(body))
    if err != nil {
        return nil, err
    }
    req.Header.Set("Authorization", "Bearer ag_live_your_key_here")
    req.Header.Set("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("agentgeo: unexpected status %s", resp.Status)
    }

    var run FetchRun
    if err := json.NewDecoder(resp.Body).Decode(&run); err != nil {
        return nil, err
    }
    return &run, nil
}

func main() {
    // surfaces: chatgpt | perplexity | gemini | google_ai_overview | google_ai_mode | copilot
    run, err := fetchRun("best running shoes for flat feet", "chatgpt")
    if err != nil {
        log.Fatal(err)
    }
    for _, answer := range run.Answers {
        fmt.Println(answer.SurfaceKey, "→", answer.AnswerText)
        for _, src := range answer.Sources { // cited sources, in order
            fmt.Println(" ", src.Position, src.Title, src.URL)
        }
    }
}

Everything lands in one FetchRun value — plain JSON on the wire, no scraping artifacts to scrub:

{
  "id": "run_84c1f2ab91d3",
  "query": "best running shoes",
  "surfaces": ["chatgpt"],
  "status": "completed",
  "recordsDelivered": 1,
  "creditsCharged": 1,
  "answers": [
    {
      "surfaceKey": "chatgpt",
      "answerText": "For most runners, top picks include ...",
      "sources": [
        { "title": "Best Running Shoes", "url": "https://example.com/guide", "position": 1 }
      ]
    }
  ]
}

Fanning a query across every engine is where Go shines — one goroutine per surface, a sync.WaitGroup, then print which URLs each engine cited:

// Fan one query across all six engines — reuses fetchRun and the structs above.
// Add "sync" to the import block.
func main() {
    surfaces := []string{"chatgpt", "perplexity", "gemini", "google_ai_overview", "google_ai_mode", "copilot"}

    var wg sync.WaitGroup
    runs := make([]*FetchRun, len(surfaces))

    for i, surface := range surfaces {
        wg.Add(1)
        go func(i int, surface string) {
            defer wg.Done()
            run, err := fetchRun("best running shoes for flat feet", surface)
            if err != nil {
                log.Printf("%s: %v", surface, err)
                return
            }
            runs[i] = run // each goroutine owns its slot — no mutex needed
        }(i, surface)
    }
    wg.Wait()

    for _, run := range runs {
        if run == nil {
            continue
        }
        for _, answer := range run.Answers {
            fmt.Println(answer.SurfaceKey, "cites:")
            for _, src := range answer.Sources {
                fmt.Println("   ", src.URL)
            }
        }
    }
}

What the Go API gives you

AgentGEO is a thin answer-access layer, not another closed dashboard. The API delivers the raw material; your Go service, worker or cron binary (or your users' AI agent) does the analysis.

• Six engines, one contract — ChatGPT, Perplexity, Google AI Overviews, Google AI Mode, Copilot and Gemini behind one request/response shape, so covering another engine is one more string in the surfaces slice.
• Citations and sources, structured — every answer decodes straight into []Source with title, URL and position, ready to store, rank or diff. No goquery, no regexing links out of markup.
• Managed-scraper engine, maintained for you — answers come through supported access paths, so there is no chromedp session to supervise, no proxy list to rotate and no IP ban to recover from mid-run.
• Provider metadata — every response carries surfaceKey and providerFields, so the dataset you build stays auditable as the engines underneath evolve.
• MCP connection, too — the same data is exposed over MCP through the agentgeo-mcp package, so Claude Code, Cursor, Codex or any MCP client can pull answers and run the GEO analysis itself, no glue code.
• Usage-based billing with a spend cap — start on the free tier with no credit card, then subscription plus overage, priced by usage and never per seat.

Common problems with DIY answer-scraping in Go

The Go-native instinct is chromedp or rod: drive ChatGPT or Perplexity over the DevTools protocol and pull answers out of the DOM. The first version compiles quickly — Go always does — and then the maintenance begins.

• chromedp and rod become the project. Driving headless Chrome over the DevTools protocol means allocator contexts, cancel funcs and lifecycle hooks for every tracked query — a browser-orchestration layer bolted onto what should be one HTTP call.
• DevTools-protocol flakiness. Targets detach, websockets drop and context deadline exceeded fires nondeterministically under load. Retrying a stateful browser session is far harder than retrying a stateless POST.
• No stable selectors on chat UIs. ChatGPT and Perplexity render through client-side JS with hashed, ever-shifting class names; your node queries start returning empty strings after a frontend deploy you'll never see coming.
• Goroutine leaks around browser contexts. Fanning out means goroutines holding Chrome tabs; one missed cancel() and memory climbs until the pod is OOM-killed. Add residential proxies and backoff to dodge the anti-bot walls, and none of it ships product.
• CI images that must bundle Chromium. The day your binary needs a browser, cross-compiling to a scratch container is over — you now ship 300 MB images with a pinned Chrome, fonts and shared libraries, for a marketing metric.

Prefer MCP? Same data, no glue code

Everything the REST endpoint returns is also exposed over MCP. When the consumer is an AI agent rather than a Go service — Claude Code, Cursor, Codex or any MCP client — one command wires it up, and the agent pulls answers and runs the GEO analysis itself:

claude mcp add agentgeo -- npx -y agentgeo-mcp --key ag_live_your_key_here

Who builds on this

Mostly backend engineers embedding AI-visibility tracking in an existing product — a Go worker that fans a keyword set across six engines and writes citations to Postgres is an afternoon of code — plus agencies white-labeling GEO/AEO reporting for clients. If you compared closed dashboards like Profound and wanted the raw data underneath, or you were sketching your own scraper, this is the layer to build on.