capturekit

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 6, 2026 License: MIT Imports: 18 Imported by: 0

README

CaptureKit Go SDK

The official Go SDK for the CaptureKit screenshot API.

Capture websites as PNG, JPEG, WebP or PDF, extract their content, or analyse them with AI.

The SDK exposes 7 typed methods, one per documented endpoint, plus a generic Request(). It has no dependencies outside the standard library.

Requirements

  • Go 1.22 or newer

Installation

go get github.com/capturekitdev/capturekit-go

Get your API key

Sign up for CaptureKit or sign in, then copy your API key from the dashboard. NewClient("", nil) reads the CAPTUREKIT_API_KEY environment variable.

Quick start

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/capturekitdev/capturekit-go"
)

func main() {
	client, err := capturekit.NewClient("", nil) // reads CAPTUREKIT_API_KEY
	if err != nil {
		log.Fatal(err)
	}
	ctx := context.Background()
	response, err := client.Content(ctx, &capturekit.ContentParams{URL: "https://example.com"})
	if err != nil {
		log.Fatal(err)
	}
	data, err := response.Map()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(data)
}

Parameter structs mirror the API reference. Required fields are plain values; optional fields are pointers — use capturekit.String, capturekit.Float, capturekit.Int and capturekit.Bool.

Decode into your own types with response.Decode(&value).

Binary responses

Endpoints that return a file (image, PDF…) give you the bytes in Body; IsJSON tells both cases apart:

response, err := client.Capture(ctx, &capturekit.CaptureParams{URL: "https://example.com", Format: capturekit.String("png")})
if err != nil {
	log.Fatal(err)
}
if !response.IsJSON {
	err = os.WriteFile("screenshot.png", response.Body, 0o644)
}

Async jobs

Any call accepts is_async: true (useful past the 60-second server limit): the response is then a job_id. WaitForJob polls GET /v1/jobs/{id} until a terminal status (CompletedJob, Error, NotFound, BadRequest):

submitted, err := client.Content(ctx, &capturekit.ContentParams{URL: "https://example.com", IsAsync: capturekit.Bool(true)})
if err != nil {
	log.Fatal(err)
}
var accepted struct{ JobID string `json:"job_id"` }
if err := submitted.Decode(&accepted); err != nil {
	log.Fatal(err)
}
job, err := client.WaitForJob(ctx, accepted.JobID, &capturekit.WaitForJobOptions{
	OnProgress: func(job map[string]any) { fmt.Println(job["status"], job["progress"]) },
})

GET or POST

Methods use GET when the endpoint supports it (parameters in the query string); WithMethod("POST") sends them as a JSON body.

response, err := client.Analyze(ctx, &capturekit.AnalyzeParams{URL: "test"}, capturekit.WithMethod("POST"))

Any endpoint

response, err := client.Request(ctx, "GET", "/v1/usage", nil)

Errors

response, err := client.Content(ctx, &capturekit.ContentParams{URL: "https://example.com"})
if apiError, ok := capturekit.IsAPIError(err); ok {
	log.Printf("HTTP %d: %s", apiError.StatusCode, apiError.Message)
}
Error When
*ConfigurationError Missing API key, invalid options or unsupported method.
*SerializationError A required parameter is missing or a value can't be sent.
*TransportError Network failure, timeout or cancelled context (errors.Is(err, context.DeadlineExceeded)).
*APIError Non-2xx status (StatusCode, Message, Response).
*ResponseDecodingError A success response could not be decoded.

Retries

Requests are retried up to 3 times after a network error, a 408, 500, 502, 503 or 504, or a rate limit — which the API returns as 401 (or 429) with a Rate limit exceeded message. Per-key quota errors (…: quota daily) are not retried, nor are 400, 402, 404 or client-side timeouts. The delay starts at 1 second and grows 1.5× per retry (capped at 30 seconds); a Retry-After header wins.

client, err := capturekit.NewClient("", &capturekit.ClientOptions{
	MaxRetries: 5,                      // negative disables retries
	RetryDelay: 500 * time.Millisecond,
})

// or for one request
response, err := client.Content(ctx, &capturekit.ContentParams{URL: "https://example.com"}, capturekit.WithMaxRetries(0))

Batch requests

capturekit.Batch runs a function per item with at most 10 calls in flight and returns one BatchResult per item, in input order. A failing item never stops the others.

inputs := []string{"https://example.com", "https://www.capturekit.dev", "https://github.com"}
results := capturekit.Batch(ctx, inputs, 5, func(ctx context.Context, value string) (*capturekit.Response, error) {
	return client.Content(ctx, &capturekit.ContentParams{URL: value})
})
for _, result := range results {
	if result.Err != nil {
		log.Printf("%s: %v", inputs[result.Index], result.Err)
		continue
	}
	fmt.Println(string(result.Value.Body))
}
Constant Default Description
DefaultConcurrency 10 Tasks run at the same time by batch
DefaultTimeout 120 * time.Second Request timeout
MaxRetries 3 Retry attempts after a network error, a 408/5xx or a rate limit
RetryBackoffFactor 1.5 Exponential backoff multiplier
DefaultRetryDelay time.Second Delay before the first retry

Timeouts and custom HTTP clients

client, err := capturekit.NewClient("", &capturekit.ClientOptions{
	Timeout:    60 * time.Second, // default 120 s; negative disables
	HTTPClient: &http.Client{Transport: myTransport},
})

Every method also honours the deadline and cancellation of the context.Context you pass.

Endpoints

7 methods, generated from the OpenAPI document.

Method HTTP Description
Analyze GET / POST /v1/analyze AI Content API analyzes any webpage and returns AI insights summary, value proposition, features, categories, use cases, and optional conta…
Capture GET / POST /v1/capture Browser-like Screenshot API that captures webpages as PNG/JPEG/WebP or PDF for previews, QA, reporting, monitoring, and archiving no headle…
Content GET / POST /v1/content CaptureKit Content API extracts structured webpage data, metadata, links, HTML/Markdown: in one request for SEO, monitoring, indexing and a…
Jobs GET /v1/jobs/{id} Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: Completed…
Stats GET /v1/stats Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 mea…
Usage GET /v1/usage Retrieve real-time usage statistics and credit balance for your CaptureKit account.
WebsiteCrawler GET / POST /v1/website/crawler Website Crawler API fetches raw HTML from any webpage in request mode (no rendering) for fast scraping, audits, monitoring, and link/metada…

License

MIT — see LICENSE.

Documentation

Overview

Package capturekit is the official Go SDK for the CaptureKit API (https://www.capturekit.dev).

Capture websites as PNG, JPEG, WebP or PDF, extract their content, or analyse them with AI.

Create one client and reuse it: 

client, err := capturekit.NewClient("", nil) // reads CAPTUREKIT_API_KEY
response, err := client.Content(ctx, ...)

Every documented endpoint has a typed method; Client.Request reaches any other path.

Index

Constants

View Source 
const (
	// DefaultBaseURL is the production API origin.
	DefaultBaseURL = "https://api.capturekit.dev"
	// DefaultTimeout bounds every request unless ClientOptions.Timeout says otherwise.
	DefaultTimeout = 120 * time.Second
	// APIKeyEnvironmentVariable is read when NewClient receives an empty API key.
	APIKeyEnvironmentVariable = "CAPTUREKIT_API_KEY"
	// DefaultConcurrency is the number of tasks Batch runs at the same time.
	DefaultConcurrency = 10
	// MaxRetries is the default number of retries after a network error or a 408, 429, 500, 502, 503 or 504.
	MaxRetries = 3
	// RetryBackoffFactor multiplies the delay before each new retry (a Retry-After header wins).
	RetryBackoffFactor = 1.5
	// DefaultRetryDelay is the delay before the first retry.
	DefaultRetryDelay = time.Second
	// MaxRetryDelay caps the delay between two attempts.
	MaxRetryDelay = 30 * time.Second
)
View Source 
const Version = "0.1.0"

Version is the SDK version sent in the User-Agent header.

Variables

View Source 
var JobTerminalStatuses = []string{"CompletedJob", "Error", "NotFound", "BadRequest"}

JobTerminalStatuses are the job statuses WaitForJob stops on.

Functions

func Bool 

func Bool(v bool) *bool

Bool returns a pointer to v, for optional boolean parameters.

func Float 

func Float(v float64) *float64

Float returns a pointer to v, for optional number parameters.

func Int 

func Int(v int64) *int64

Int returns a pointer to v, for optional integer parameters.

func String 

func String(v string) *string

String returns a pointer to v, for optional parameters.

Types

type APIError 

type APIError struct {
	StatusCode int
	// Message is the "error" (or "message") field of the JSON body, when present.
	Message  string
	Response *Response
}

APIError is returned for non-2xx responses.

func IsAPIError 

func IsAPIError(err error) (*APIError, bool)

IsAPIError reports whether err is an *APIError and returns it.

func (*APIError) Error 

func (e *APIError) Error() string

type AnalyzeParams 

type AnalyzeParams struct {
	// The URL of the webpage to capture.
	URL string `json:"url" api:"url,required"`
	// Pass custom response fields to be included in the AI response.
	CustomResponse *string `json:"custom_response" api:"custom_response"`
	// Add your own instructions to guide the AI’s analysis.
	CustomPrompt *string `json:"custom_prompt" api:"custom_prompt"`
	// Specify a proxy server to route your request through.
	Proxy *string `json:"proxy" api:"proxy"`
	// Cache the response. Default: false.
	Cache *bool `json:"cache" api:"cache"`
	// Cache the response for a custom TTL (in seconds). Default: 2592000.
	CacheTTL *float64 `json:"cache_ttl" api:"cache_ttl"`
	// Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
	Fields *string `json:"fields" api:"fields"`
	// Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob). Default: false.
	IsAsync *bool `json:"is_async" api:"is_async"`
	// Return HTTP 200 even when an error occurs; the error is then in the response body. Default: false.
	SoftFail *bool `json:"soft_fail" api:"soft_fail"`
}

AnalyzeParams holds the parameters of Analyze (GET / POST /v1/analyze). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

type BatchResult 

type BatchResult[T any] struct {
	Index int
	Value T
	Err   error
}

BatchResult is the outcome of one Batch item.

func Batch 

func Batch[I, T any](ctx context.Context, items []I, concurrency int, task func(ctx context.Context, item I) (T, error)) []BatchResult[T]

Batch runs task for every item with at most concurrency calls in flight (DefaultConcurrency when concurrency <= 0) and returns one result per item, in input order. A failing item never stops the others; items not started when ctx is done get ctx.Err().

type CaptureParams 

type CaptureParams struct {
	// The URL of the webpage to capture. Examples:  https://www.amazon.com/s?k=pokemon
	URL string `json:"url" api:"url,required"`
	// The output format of the screenshot. Allowed values: jpeg, jpg, pdf, png, webp. Default: "png".
	Format *string `json:"format" api:"format"`
	// The device type to emulate for the screenshot. Allowed values: galaxy_fold4, galaxy_s23, galaxy_s23_ultra, galaxy_s8, huawei_mate_50_pro, huawei_p60_pro, ipad, iphone_12, iphone_13_mini, iphone_13_pro_max, iphone_14_pro, iphone_14_pro_max, iphone_x, pixel_5, pixel_6a, pixel_7_pro, redmi_note_11, re…
	Device *string `json:"device" api:"device"`
	// Capture the entire page instead of just the visible viewport. Default: false.
	FullPage *bool `json:"full_page" api:"full_page"`
	// Scroll the page to fully load lazy-loaded elements before capturing a full-page screenshot. Default: false.
	FullPageScroll *bool `json:"full_page_scroll" api:"full_page_scroll"`
	// Time in milliseconds for scrolling before capturing the full page. Default: 400.
	FullPageScrollDuration *float64 `json:"full_page_scroll_duration" api:"full_page_scroll_duration"`
	// The width of the browser viewport in pixels. Default: 1280.
	ViewportWidth *float64 `json:"viewport_width" api:"viewport_width"`
	// The height of the browser viewport in pixels. Default: 1024.
	ViewportHeight *float64 `json:"viewport_height" api:"viewport_height"`
	// The scale factor for high-resolution screenshots. Default: 1.
	ScaleFactor *float64 `json:"scale_factor" api:"scale_factor"`
	// Generate images with custom quality settings. Default: "80".
	ImageQuality *string `json:"image_quality" api:"image_quality"`
	// Capture a specific element on the page instead of the full viewport.
	Selector *string `json:"selector" api:"selector"`
	// Cache the response. Default: false.
	Cache *bool `json:"cache" api:"cache"`
	// Cache the response for a custom TTL (in seconds). Default: 2592000.
	CacheTTL *float64 `json:"cache_ttl" api:"cache_ttl"`
	// A comma-separated list of elements to hide before capturing (e.g., ads, popups).
	RemoveSelectors *string `json:"remove_selectors" api:"remove_selectors"`
	// Automatically remove cookie banners before capturing. Default: false.
	RemoveCookieBanners *bool `json:"remove_cookie_banners" api:"remove_cookie_banners"`
	// Automatically remove ads before capturing. Default: false.
	RemoveAds *bool `json:"remove_ads" api:"remove_ads"`
	// Comma-separated list of resource types to block (e.g., “image,stylesheet,font”). Allowed values: document, eventsource, fetch, font, image, manifest, media, other, script, stylesheet, texttrack, websocket, xhr.
	BlockResources *string `json:"block_resources" api:"block_resources"`
	// Comma-separated list of URL patterns to block (e.g., “analytics,tracking,advertisement”).
	BlockUrls *string `json:"block_urls" api:"block_urls"`
	// Delay in seconds before capturing the screenshot. Default: 0.
	Delay *float64 `json:"delay" api:"delay"`
	// Define when to capture. Allowed values: domcontentloaded, load, networkidle0, networkidle2.
	WaitUntil []string `json:"wait_until" api:"wait_until"`
	// Wait for a specific element to appear before taking the screenshot.
	WaitForSelector *string `json:"wait_for_selector" api:"wait_for_selector"`
	// Specify a proxy server to route your request through.
	Proxy *string `json:"proxy" api:"proxy"`
	// AWS S3 secret access key.
	S3SecretKey *string `json:"s3_secret_key" api:"s3_secret_key"`
	// AWS S3 access key ID.
	S3AccessKeyID *string `json:"s3_access_key_id" api:"s3_access_key_id"`
	// The S3 bucket name where the screenshot will be uploaded.
	S3Bucket *string `json:"s3_bucket" api:"s3_bucket"`
	// The filename for the S3 object (auto-generated if not provided).
	S3ObjectKey *string `json:"s3_object_key" api:"s3_object_key"`
	// AWS S3 region for storage.
	S3Region *string `json:"s3_region" api:"s3_region"`
	// Leave this field empty for AWS S3. Only specify a value if required. S3-compatible storage services are supported, for example, use https://<accountId>.r2.cloudflarestorage.com for Cloudflare R2.
	StorageEndpoint *string `json:"storage_endpoint" api:"storage_endpoint"`
	// Use S3 storage for screenshots. The S3 URL will be returned in the response. Default: false.
	S3URL *bool `json:"s3_url" api:"s3_url"`
	// Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
	Fields *string `json:"fields" api:"fields"`
	// Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob). Default: false.
	IsAsync *bool `json:"is_async" api:"is_async"`
	// Return HTTP 200 even when an error occurs; the error is then in the response body. Default: false.
	SoftFail *bool `json:"soft_fail" api:"soft_fail"`
}

CaptureParams holds the parameters of Capture (GET / POST /v1/capture). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client is a reusable, concurrency-safe CaptureKit API client.

func NewClient 

func NewClient(apiKey string, options *ClientOptions) (*Client, error)

NewClient creates a client. An empty apiKey falls back to the CAPTUREKIT_API_KEY environment variable.

func (*Client) Analyze 

func (c *Client) Analyze(ctx context.Context, params *AnalyzeParams, options ...RequestOption) (*Response, error)

Analyze — Analyze (AI). AI Content API analyzes any webpage and returns AI insights summary, value proposition, features, categories, use cases, and optional contact signals. Credit cost: 1 credit per call.

GET / POST /v1/analyze

func (*Client) Capture 

func (c *Client) Capture(ctx context.Context, params *CaptureParams, options ...RequestOption) (*Response, error)

Capture — Capture (Screenshot). Browser-like Screenshot API that captures webpages as PNG/JPEG/WebP or PDF for previews, QA, reporting, monitoring, and archiving no headless setup. Credit cost: 1 credit per call.

GET / POST /v1/capture

func (*Client) Content 

func (c *Client) Content(ctx context.Context, params *ContentParams, options ...RequestOption) (*Response, error)

Content — Content. CaptureKit Content API extracts structured webpage data, metadata, links, HTML/Markdown: in one request for SEO, monitoring, indexing and automation. Credit cost: 1 credit per call.

GET / POST /v1/content

func (*Client) Jobs 

func (c *Client) Jobs(ctx context.Context, params *JobsParams, options ...RequestOption) (*Response, error)

Jobs — Jobs. Poll the status, progress (0–100) and result of a job started with is_async=true. Polling is free. Poll until status is terminal: CompletedJob, Error, NotFound or BadRequest.

GET /v1/jobs/{id}

func (*Client) Request 

func (c *Client) Request(ctx context.Context, method, path string, params map[string]any, options ...RequestOption) (*Response, error)

Request sends any request, including endpoints released after this SDK version. GET parameters travel in the query string; POST parameters travel in a JSON body.

func (*Client) Stats 

func (c *Client) Stats(ctx context.Context, params *StatsParams, options ...RequestOption) (*Response, error)

Stats — Stats. Infrastructure health for an engine or endpoint over the last hour. Not scoped to your account or tenant. Enabled per account: HTTP 403 means contact support to activate it.

GET /v1/stats

func (*Client) Usage 

func (c *Client) Usage(ctx context.Context, options ...RequestOption) (*Response, error)

Usage — Usage. Retrieve real-time usage statistics and credit balance for your CaptureKit account.

GET /v1/usage

func (*Client) WaitForJob 

func (c *Client) WaitForJob(ctx context.Context, jobID string, options *WaitForJobOptions) (*Response, error)

WaitForJob polls GET /v1/jobs/{id} until the job reaches a terminal status and returns the last response.

func (*Client) WebsiteCrawler 

func (c *Client) WebsiteCrawler(ctx context.Context, params *WebsiteCrawlerParams, options ...RequestOption) (*Response, error)

WebsiteCrawler — Website Crawler. Website Crawler API fetches raw HTML from any webpage in request mode (no rendering) for fast scraping, audits, monitoring, and link/metadata extraction. Credit cost: 1 credit per call.

GET / POST /v1/website/crawler

type ClientOptions 

type ClientOptions struct {
	// BaseURL overrides DefaultBaseURL.
	BaseURL string
	// Timeout bounds each request. Zero uses DefaultTimeout; a negative value disables it.
	Timeout time.Duration
	// HTTPClient is copied and used for requests. Redirects are never followed.
	HTTPClient *http.Client
	// Headers are sent with every request.
	Headers map[string]string
	// MaxRetries overrides the number of retries. Zero uses MaxRetries; a negative value disables retries.
	MaxRetries int
	// RetryDelay is the delay before the first retry. Zero uses DefaultRetryDelay.
	RetryDelay time.Duration
}

ClientOptions configures a Client. The zero value is valid.

type ConfigurationError 

type ConfigurationError struct {
	Message string
	Err     error
}

ConfigurationError reports a missing or unusable client configuration.

func (*ConfigurationError) Error 

func (e *ConfigurationError) Error() string

func (*ConfigurationError) Unwrap 

func (e *ConfigurationError) Unwrap() error

type ContentParams 

type ContentParams struct {
	// The URL of the webpage to capture.
	URL string `json:"url" api:"url,required"`
	// Include the raw HTML of the webpage in the response. Default: false.
	IncludeHTML *bool `json:"include_html" api:"include_html"`
	// Include the Markdown of the webpage in the response. Default: false.
	IncludeMarkdown *bool `json:"include_markdown" api:"include_markdown"`
	// Include the sitemap of the website in the response. Default: false.
	IncludeSitemap *bool `json:"include_sitemap" api:"include_sitemap"`
	// Use Defuddle to clean and extract the main content from web pages. This popular library removes unnecessary elements like comments, sidebars, headers, footers, and other non-essential elements, leaving only the primary content. When enabled, the HTML response will be processed through Defuddle befo…
	UseDefuddle *bool `json:"use_defuddle" api:"use_defuddle"`
	// A comma-separated list of elements to hide before capturing (e.g., ads, popups).
	RemoveSelectors *string `json:"remove_selectors" api:"remove_selectors"`
	// Automatically remove cookie banners before capturing. Default: false.
	RemoveCookieBanners *bool `json:"remove_cookie_banners" api:"remove_cookie_banners"`
	// Automatically remove ads before capturing. Default: false.
	RemoveAds *bool `json:"remove_ads" api:"remove_ads"`
	// Comma-separated list of resource types to block (e.g., “image,stylesheet,font”). Allowed values: document, eventsource, fetch, font, image, manifest, media, other, script, stylesheet, texttrack, websocket, xhr.
	BlockResources *string `json:"block_resources" api:"block_resources"`
	// Comma-separated list of URL patterns to block (e.g., “analytics,tracking,advertisement”).
	BlockUrls *string `json:"block_urls" api:"block_urls"`
	// Delay in seconds before capturing the screenshot. Default: 0.
	Delay *float64 `json:"delay" api:"delay"`
	// Define when to capture. Allowed values: domcontentloaded, load, networkidle0, networkidle2.
	WaitUntil []string `json:"wait_until" api:"wait_until"`
	// Wait for a specific element to appear before taking the screenshot.
	WaitForSelector *string `json:"wait_for_selector" api:"wait_for_selector"`
	// Specify a proxy server to route your request through.
	Proxy *string `json:"proxy" api:"proxy"`
	// Cache the response. Default: false.
	Cache *bool `json:"cache" api:"cache"`
	// Cache the response for a custom TTL (in seconds). Default: 2592000.
	CacheTTL *float64 `json:"cache_ttl" api:"cache_ttl"`
	// Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
	Fields *string `json:"fields" api:"fields"`
	// Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob). Default: false.
	IsAsync *bool `json:"is_async" api:"is_async"`
	// Return HTTP 200 even when an error occurs; the error is then in the response body. Default: false.
	SoftFail *bool `json:"soft_fail" api:"soft_fail"`
}

ContentParams holds the parameters of Content (GET / POST /v1/content). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

type JobTimeoutError 

type JobTimeoutError struct {
	JobID        string
	LastResponse *Response
}

JobTimeoutError reports an async job that did not finish before the deadline.

func (*JobTimeoutError) Error 

func (e *JobTimeoutError) Error() string

type JobsParams 

type JobsParams struct {
	// The job_id returned by an endpoint called with is_async=true.
	ID string `json:"id" api:"id,required"`
}

JobsParams holds the parameters of Jobs (GET /v1/jobs/{id}). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

type RequestOption 

type RequestOption func(*requestOptions)

RequestOption customizes one request.

func WithHeader 

func WithHeader(name, value string) RequestOption

WithHeader adds a header to one request.

func WithMaxRetries 

func WithMaxRetries(n int) RequestOption

WithMaxRetries overrides the number of retries for one request (0 disables them).

func WithMethod 

func WithMethod(method string) RequestOption

WithMethod selects GET or POST. Operations default to GET when they support it.

type Response 

type Response struct {
	StatusCode  int
	Header      http.Header
	ContentType string
	// Body holds the raw bytes: JSON text, or a file such as an image or PDF.
	Body []byte
	// IsJSON reports whether the body is JSON (Content-Type application/json or +json).
	IsJSON bool
}

Response is a buffered, successful API response.

func (*Response) Decode 

func (r *Response) Decode(v any) error

Decode unmarshals a JSON body into v.

func (*Response) Map 

func (r *Response) Map() (map[string]any, error)

Map decodes a JSON object body.

type ResponseDecodingError 

type ResponseDecodingError struct {
	Message  string
	Response *Response
	Err      error
}

ResponseDecodingError reports a success response that could not be decoded.

func (*ResponseDecodingError) Error 

func (e *ResponseDecodingError) Error() string

func (*ResponseDecodingError) Unwrap 

func (e *ResponseDecodingError) Unwrap() error

type SerializationError 

type SerializationError struct {
	Param   string
	Message string
	Err     error
}

SerializationError reports a parameter that is missing or cannot be sent.

func (*SerializationError) Error 

func (e *SerializationError) Error() string

func (*SerializationError) Unwrap 

func (e *SerializationError) Unwrap() error

type StatsParams 

type StatsParams struct {
	// API family to check, for example capture. Provide at least engine or path.
	Engine *string `json:"engine" api:"engine"`
	// Specific endpoint to check, for example /v1/capture. If you also pass engine, use an endpoint from that API.
	Path *string `json:"path" api:"path"`
}

StatsParams holds the parameters of Stats (GET /v1/stats). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

type TransportError 

type TransportError struct {
	Message string
	Err     error
}

TransportError reports a failure before a complete HTTP response was received, including client-side timeouts and context cancellation (see Unwrap).

func (*TransportError) Error 

func (e *TransportError) Error() string

func (*TransportError) Unwrap 

func (e *TransportError) Unwrap() error

type WaitForJobOptions 

type WaitForJobOptions struct {
	Interval   time.Duration
	Timeout    time.Duration
	OnProgress func(job map[string]any)
}

WaitForJobOptions configures WaitForJob. The zero value polls after 3 s, then 1.5x longer each time up to 60 s, for up to 12 hours.

type WebsiteCrawlerParams 

type WebsiteCrawlerParams struct {
	// A website URL with either the http or https protocol.
	Query string `json:"query" api:"query,required"`
	// If set to false, do not follow redirects. Default: true.
	AllowRedirects *bool `json:"allow_redirects" api:"allow_redirects"`
	// If set to true, the response will be the HTML source of the page. Default: false.
	ReturnPageSource *bool `json:"return_page_source" api:"return_page_source"`
	// Comma-separated list of fields to keep in the response, with dot notation for nested fields (e.g. name,location.city). Does not change the credit cost.
	Fields *string `json:"fields" api:"fields"`
	// Process the request asynchronously: the response is a job_id to poll on /v1/jobs/{id} (see waitForJob). Default: false.
	IsAsync *bool `json:"is_async" api:"is_async"`
	// Return HTTP 200 even when an error occurs; the error is then in the response body. Default: false.
	SoftFail *bool `json:"soft_fail" api:"soft_fail"`
}

WebsiteCrawlerParams holds the parameters of WebsiteCrawler (GET / POST /v1/website/crawler). Required fields are plain values; optional fields are pointers (use capturekit.String, capturekit.Float, capturekit.Bool) or nil slices and maps.

Source Files

View all Source files

Directories

Path Synopsis
examples
binary command
json command
request command
wait-for-job command

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.