Go SDK

go get -u github.com/scrapeless-ai/sdk-go

export SCRAPELESS_API_KEY="YOUR_API_KEY"

package main
 
import (
    "context"
    "fmt"
    "log"
 
    "github.com/scrapeless-ai/sdk-go/scrapeless"
    "github.com/scrapeless-ai/sdk-go/scrapeless/services/universal"
)
 
func main() {
    client := scrapeless.New(scrapeless.WithUniversal())
    defer client.Close()
 
    result, err := client.Universal.CreateTask(context.Background(), universal.UniversalTaskRequest{
        Actor: universal.ScraperUniversal,
        Input: map[string]any{
            "url": "https://example.com",
            "method": "GET",
            "redirect": false,
        },
    })
    if err != nil {
        log.Print(err)
        return
    }
    fmt.Printf("%+v\n", result)
}

package main
 
import (
	"context"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/log"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/browser"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithBrowser())
	defer client.Close()
 
	browserInfo, err := client.Browser.Create(context.Background(), browser.Actor{
		Input:        browser.Input{SessionTtl: "180"},
		ProxyCountry: "US",
	})
	if err != nil {
		panic(err)
	}
	log.Infof("%+v", browserInfo)
}

package main
 
import (
	"context"
	"fmt"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithProfile())
	defer client.Close()
 
	result, err := client.Profile.CreateProfile(context.Background(), "My Profile")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", result)
}

package main
 
import (
	"context"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/log"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/scraping"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithScraping())
	defer client.Close()
 
	scrape, err := client.Scraping.Scrape(context.Background(), scraping.ScrapingTaskRequest{
		Actor: "scraper.google.search",
		Input: map[string]interface{}{
			"q": "nike site:www.nike.com",
		},
		ProxyCountry: "US",
	})
	if err != nil {
		log.Errorf("scraping create err:%v", err)
		return
	}
	log.Infof("%+v", scrape)
}

package main
 
import (
	"context"
	"fmt"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/universal"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithUniversal())
	defer client.Close()
 
	result, err := client.Universal.CreateTask(context.Background(), universal.UniversalTaskRequest{
		Actor: universal.ScraperUniversal,
		Input: map[string]any{
			"url":      "https://example.com",
			"method":   "GET",
			"redirect": false,
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", result)
}

package main
 
import (
	"context"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/log"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/crawl"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithCrawl())
	defer client.Close()
 
	// Crawl
	response, err := client.Crawl.CrawlUrl(context.Background(), "https://redditinc.com/blog", crawl.CrawlParams{
		Limit: 10,
		ScrapeOptions: crawl.ScrapeOptions{
			Formats: []string{"links",
				"markdown",
				"html",
				"screenshot"},
		},
		BrowserOptions: crawl.ICreateBrowser{
			SessionName:      "Crawl",
			SessionTTL:       "900",
			SessionRecording: "true",
			ProxyCountry:     "ANY",
		},
	})
	if err != nil {
		panic(err)
	}
	log.Infof("Crawl response: %v", response)
 
	// scrape
	scrapeResponse, err := client.Crawl.ScrapeUrl(context.Background(), "https://docs.scrapeless.com/en/docs/get-started/overview/", crawl.ScrapeOptions{
		BrowserOptions: crawl.ICreateBrowser{
			SessionName:      "Crawl",
			SessionTTL:       "900",
			SessionRecording: "true",
			ProxyCountry:     "ANY",
		},
	})
	if err != nil {
		panic(err)
	}
	log.Infof("Scrape response: %v", scrapeResponse)
}

package main
 
import (
	"context"
	"fmt"
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/proxies"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithProxy())
	defer client.Close()
 
	result, err := client.Proxy.Proxy(context.Background(), proxies.ProxyActor{
		Country:         "US",
		SessionDuration: 30,
		SessionId:       "my-session",
		Gateway:         "your-proxy-gateway:port",
	})
	if err != nil {
		panic(err)
	}
	fmt.Printf("%+v\n", result)
}

package main
 
import (
	"context"
	"encoding/json"
	"fmt"
 
	"github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/aiscraper"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithAIScraper()) // Uses SCRAPELESS_API_KEY
	defer client.Close()
	ctx := context.Background()
 
	task, err := client.AIScraper.CreateTask(ctx, aiscraper.TaskRequest{
		Actor: "scraper.chatgpt",
		Input: map[string]any{
			"prompt":     "Most reliable proxy service for data extraction",
			"country":    "US",
			"web_search": true,
		},
		// Optional: Webhook: map[string]any{"url": "https://your-webhook.example.com"},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println("Created task:", string(task))
 
	var created struct {
		TaskID string `json:"task_id"`
	}
	if err := json.Unmarshal(task, &created); err != nil {
		panic(err)
	}
	result, err := client.AIScraper.GetTaskResult(ctx, created.TaskID)
	if err != nil {
		panic(err)
	}
	fmt.Println("Task status and result:", string(result))
	// If status is "running", call GetTaskResult again later.
	// If status is "failed", message contains the failure reason.
}

package main
 
import (
	"context"
	scrapeless "github.com/scrapeless-ai/sdk-go/scrapeless"
	"github.com/scrapeless-ai/sdk-go/scrapeless/log"
	"github.com/scrapeless-ai/sdk-go/scrapeless/services/deepserp"
)
 
func main() {
	client := scrapeless.New(scrapeless.WithDeepSerp())
	defer client.Close()
 
	scrape, err := client.DeepSerp.Scrape(context.Background(), deepserp.DeepserpTaskRequest{
		Actor: "scraper.google.search",
		Input: map[string]interface{}{
			"q": "nike site:www.nike.com",
		},
		ProxyCountry: "US",
	})
	if err != nil {
		log.Errorf("scraping create err:%v", err)
		return
	}
	log.Infof("%+v", scrape)
}

package main
 
import (
    "context"
    "fmt"
    "log"
    "time"
 
    "github.com/scrapeless-ai/sdk-go/scrapeless"
)
 
func main() {
    client := scrapeless.New(scrapeless.WithAIScraper())
    defer client.Close()
 
    ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
    defer cancel()
 
    result, err := client.AIScraper.GetTaskResult(ctx, "YOUR_TASK_ID")
    if err != nil {
        log.Printf("Could not retrieve task: %v", err)
        return
    }
    fmt.Println(string(result))
}