There is no official Go module, and the API does not need one. net/http plus encoding/json is the whole integration.

Install

// nothing to install - net/http is standard library

Your first screenshot in Go

One POST, one JSON body, one URL back. The response is a CDN link to the finished image.

net/http

package main

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

type shotResponse struct {
    URL string `json:"url"`
}

func main() {
    body, _ := json.Marshal(map[string]any{
        "url":    "https://github.com",
        "format": "png",
    })

    req, _ := http.NewRequest("POST",
        "https://api.getsnap.dev/v1/screenshot", bytes.NewReader(body))
    req.Header.Set("X-API-Key", "sk_live_YOUR_KEY")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{Timeout: 60 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    var out shotResponse
    json.NewDecoder(resp.Body).Decode(&out)
    fmt.Println(out.URL) // CDN URL to your screenshot
}

Full-page captures and other options

Every option is a field in the same JSON body. The common ones are full-page capture, popup and ad removal, viewport size, and lazy-load scrolling.

body, _ := json.Marshal(map[string]any{
    "url":             "https://example.com",
    "format":          "png",
    "full_page":       true,
    "remove_popups":   true,
    "block_ads":       true,
    "lazy_load":       true,
    "viewport_width":  1280,
    "viewport_height": 720,
})

Saving the image to disk

By default you get a CDN URL. Ask for a binary response instead and you get the bytes directly, which saves a round-trip when you are storing the file yourself.

body, _ := json.Marshal(map[string]any{
    "url":           "https://example.com",
    "format":        "webp",
    "quality":       90,
    "response_type": "binary",
})

// ... build and send the request as above ...

f, _ := os.Create("screenshot.webp")
defer f.Close()
io.Copy(f, resp.Body)

Handling errors

Every failure returns JSON with an error code and a human-readable message. These are the ones worth branching on:

Status	error	What it means
400	validation_error	A field is missing or out of range. The body names the field.
401	unauthorized	Missing or unknown API key.
402	quota_exceeded	Monthly capture limit reached.
429	rate_limit_exceeded	Too many requests this minute. Back off and retry.
500	capture_failed	The page could not be rendered - usually a timeout on a page that never settles.

resp, err := client.Do(req)
if err != nil {
    return err
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
    var e struct {
        Error   string `json:"error"`
        Message string `json:"message"`
    }
    json.NewDecoder(resp.Body).Decode(&e)
    // e.g. 402 quota_exceeded
    return fmt.Errorf("%d %s: %s", resp.StatusCode, e.Error, e.Message)
}

Rate limits and quotas

Plan	Captures / month	Requests / minute
Free	100	5
Starter	5,000	30
Pro	25,000	60
Business	100,000	120

Exceeding the per-minute limit returns 429; exceeding the monthly quota returns 402. See pricing for the full breakdown.

Frequently asked questions

Next steps

• Code examples — every feature, with cURL, Node.js and Python tabs
• API reference — every request field and response shape
• Playground — try a capture in the browser before writing any Go
• Pricing — plans, quotas and overage

Related reading

• Best screenshot API in 2026 — how the managed options compare