Go Client

go get github.com/evomi/evomi-go-client

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/evomi/evomi-go-client/evomi"
)

func main() {
    client := evomi.NewClient("your-api-key", "", "")

    result, err := client.Scrape(context.Background(), "https://example.com", evomi.ScrapeOptions{})
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(result["content"])
}

export EVOMI_API_KEY="your-api-key"

client := evomi.NewClient("your-api-key", "", "")

client := evomi.NewClient("your-api-key", "https://custom.evomi.com", "")

result, err := client.Scrape(ctx, "https://example.com", evomi.ScrapeOptions{
    Mode:              "auto",
    Output:            "markdown",
    Device:            "windows",
    ProxyType:         "residential",
    ProxyCountry:      "US",
    ProxySessionID:    "abc123",
    WaitUntil:         "domcontentloaded",
    AIEnhance:         true,
    AIPrompt:          "Extract product data",
    AISource:          "markdown",
    JSInstructions:    []map[string]any{{"click": ".load-more"}},
    ExecuteJS:         "window.scrollTo(0, document.body.scrollHeight)",
    WaitSeconds:       2,
    Screenshot:        false,
    PDF:               false,
    ExcludedTags:      []string{"nav", "footer"},
    ExcludedSelectors: []string{".ads"},
    BlockResources:    []string{"image", "stylesheet"},
    AdditionalHeaders: map[string]string{"X-Custom": "value"},
    CaptureHeaders:    true,
    NetworkCapture:    []map[string]any{{"url_pattern": "/api/.*"}},
    AsyncMode:         false,
    ConfigID:          "cfg_abc123",
    SchemeID:          "sch_abc123",
    ExtractScheme:     []map[string]any{{"label": "title", "type": "content", "selector": "h1"}},
    StorageID:         "stor_abc123",
    UseDefaultStorage: false,

})

result, err := client.Crawl(ctx, "example.com", evomi.CrawlOptions{
    MaxURLs:       100,
    Depth:         2,
    URLPattern:    "/blog/.*",
    ScraperConfig: map[string]any{"mode": "browser", "output": "markdown"},
    AsyncMode:     false,
})

result, err := client.MapWebsite(ctx, "example.com", evomi.MapOptions{
    Sources:     []string{"sitemap", "commoncrawl"},
    MaxURLs:     500,
    URLPattern:  "/products/.*",
    CheckIfLive: false,
    Depth:       1,
    AsyncMode:   false,
})

// Single query
result, err := client.SearchDomains(ctx, "e-commerce platforms", evomi.SearchOptions{
    MaxURLs: 20,
    Region:  "us-en",
})

// Multiple queries (up to 10)
result, err := client.SearchDomains(ctx, []string{"web scraping tools", "data extraction"}, evomi.SearchOptions{
    MaxURLs: 20,
})

result, err := client.AgentRequest(ctx, "Scrape example.com and extract all product prices")

result, err := client.GetTaskStatus(ctx, "abc123", "scrape")
// taskType: "scrape" | "crawl" | "map" | "config_generate" | "schema"

configs, err := client.ListConfigs(ctx, evomi.ListConfigsOptions{
    Page:      1,
    PerPage:   20,
    SortBy:    "created_at",
    SortOrder: "desc",
})

config, err := client.CreateConfig(ctx, "Product Scraper", map[string]any{
    "mode":   "browser",
    "output": "markdown",
})

config, err := client.GetConfig(ctx, "cfg_abc123")

config, err := client.UpdateConfig(ctx, "cfg_abc123", "New Name", map[string]any{
    "mode": "request",
})

result, err := client.DeleteConfig(ctx, "cfg_abc123")

config, err := client.GenerateConfig(ctx, "Amazon Scraper",
    "Scrape product title and price from Amazon product pages")

schemas, err := client.ListSchemas(ctx, evomi.ListSchemasOptions{
    Page:      1,
    PerPage:   20,
    SortBy:    "created_at",
    SortOrder: "desc",
})

schema, err := client.CreateSchema(ctx, "Product Schema", map[string]any{
    "url": "https://example.com/product",
    "extract_scheme": []map[string]any{
        {"label": "title", "type": "content", "selector": "h1"},
        {"label": "price", "type": "content", "selector": ".price"},
    },
}, evomi.CreateSchemaOptions{
    Test: true,
    Fix:  false,
})

schema, err := client.GetSchema(ctx, "sch_abc123")

schema, err := client.UpdateSchema(ctx, "sch_abc123", "Updated Schema",
    map[string]any{"url": "...", "extract_scheme": [...]},
    evomi.CreateSchemaOptions{Test: true})

result, err := client.DeleteSchema(ctx, "sch_abc123")

status, err := client.GetSchemaStatus(ctx, "sch_abc123")

schedules, err := client.ListSchedules(ctx, evomi.ListSchedulesOptions{
    Page:       1,
    PerPage:    20,
    ActiveOnly: false,
})

schedule, err := client.CreateSchedule(ctx, "Daily Price Check", "cfg_abc123", 1440,
    evomi.CreateScheduleOptions{
        StartTime:   "09:00",
        StopOnError: true,
    })

schedule, err := client.GetSchedule(ctx, "sched_abc123")

schedule, err := client.UpdateSchedule(ctx, "sched_abc123", evomi.UpdateScheduleOptions{
    Name:            "New Name",
    IntervalMinutes: 720,
})

result, err := client.DeleteSchedule(ctx, "sched_abc123")

result, err := client.ToggleSchedule(ctx, "sched_abc123")

runs, err := client.ListScheduleRuns(ctx, "sched_abc123", evomi.ListScheduleRunsOptions{
    Page:    1,
    PerPage: 20,
})

configs, err := client.ListStorageConfigs(ctx)

// S3-compatible storage
storage, err := client.CreateStorageConfig(ctx, "My S3", "s3_compatible", map[string]any{
    "bucket":     "my-bucket",
    "region":     "us-east-1",
    "access_key": "...",
    "secret_key": "...",
}, true)

// Google Cloud Storage
storage, err := client.CreateStorageConfig(ctx, "My GCS", "gcs", map[string]any{
    "bucket":           "my-bucket",
    "credentials_json": "...",
}, false)

// Azure Blob Storage
storage, err := client.CreateStorageConfig(ctx, "My Azure", "azure_blob", map[string]any{
    "container":         "my-container",
    "connection_string": "...",
}, false)

setAsDefault := true
storage, err := client.UpdateStorageConfig(ctx, "stor_abc123", evomi.UpdateStorageOptions{
    Name:         "Renamed Storage",
    SetAsDefault: &setAsDefault,
})

result, err := client.DeleteStorageConfig(ctx, "stor_abc123")

data, err := client.GetPublicAPI(ctx)
// Returns proxy credentials and product information

data, err := client.GetProxyData(ctx)
// Returns: {"products": {"rp": {...}, "sdc": {...}, "mp": {...}}, ...}

options, err := client.GetTargetingOptions(ctx)

data, err := client.GetScraperData(ctx)

data, err := client.GetBrowserData(ctx)

result, err := client.RotateSession(ctx, "abc12345", "rp")
// product: "rpc", "rp", "sdc", "mp"

adblock := true
prependProtocol := true
proxies, err := client.GenerateProxies(ctx, "rp", evomi.GenerateProxiesOptions{
    Countries:       "US,GB,DE",
    City:            "New York",
    Session:         "sticky",
    Amount:          10,
    Protocol:        "http",
    Lifetime:        30,
    Adblock:         &adblock,
    PrependProtocol: &prependProtocol,
})
// Returns plain text, one proxy per line

info, err := client.GetAccountInfo(ctx)
fmt.Println(info["credits_remaining"])

import "github.com/evomi/evomi-go-client/evomi"

// Discord webhook
webhook := &evomi.WebhookConfig{
    URL:    "https://discord.com/api/webhooks/...",
    Type:   "discord",
    Events: []string{"completed", "failed"},
}

// Custom webhook with HMAC signature
webhook := &evomi.WebhookConfig{
    URL:    "https://your-server.com/webhook",
    Type:   "custom",
    Events: []string{"completed"},
    Secret: "your-secret-key",
}

webhook := &evomi.WebhookConfig{
    URL:    "https://discord.com/api/webhooks/...",
    Type:   "discord",
    Events: []string{"completed", "failed"},
}

result, err := client.Scrape(ctx, "https://example.com", evomi.ScrapeOptions{
    Mode:    "browser",
    Webhook: webhook,
})

// With crawl
result, err := client.Crawl(ctx, "example.com", evomi.CrawlOptions{
    MaxURLs: 100,
    Webhook: webhook,
})

// With MapWebsite
result, err := client.MapWebsite(ctx, "example.com", evomi.MapOptions{
    Webhook: webhook,
})

// With SearchDomains
result, err := client.SearchDomains(ctx, "e-commerce platforms", evomi.SearchOptions{
    Webhook: webhook,
})

schedule, err := client.CreateSchedule(ctx, "Daily Price Check", "cfg_abc123", 1440,
    evomi.CreateScheduleOptions{
        StartTime:   "09:00",
        StopOnError: true,
        Webhook:     webhook,
    })

client := evomi.NewClient("your-api-key", "", "")

proxyString, err := client.BuildProxyString(ctx, evomi.ProxyTypeResidential, struct {
    Country string
    Session string
}{
    Country: "US",
    Session: "abc12345",
})
fmt.Println(proxyString)
// Output: http://user:[email protected]:1000

config := &evomi.ProxyConfig{
    ProxyType:  evomi.ProxyTypeResidential,
    Protocol:   evomi.ProxyProtocolHTTP,
    Country:    "US",
    City:       "New York",
    Username:   "your-username",
    Password:   "your-password",
}

proxyString := config.BuildProxyString()

result, err := client.Scrape(ctx, "https://example.com", evomi.ScrapeOptions{})
if err != nil {
    log.Fatal(err)
}

if success, ok := result["success"].(bool); !ok || !success {
    fmt.Println("API error:", result["error"])
}

fmt.Println(result["_credits_used"])
fmt.Println(result["_credits_remaining"])