Go SDK

Descripción general

El SDK oficial de Go de Scrapeless proporciona acceso a automatización de navegadores, extracción de datos, rastreo, proxies, resultados de búsqueda y extracción de chat de IA. Esta guía sigue el README del repositorio del SDK, con ejemplos ejecutables y detalles de configuración.

Requisitos

Se requiere Go 1.24.0 o posterior según el archivo go.mod del repositorio. Ejecute el comando de instalación dentro de un módulo de Go. Para un proyecto nuevo, inicialícelo con go mod init example.com/scrapeless-demo.

Instalación

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

Autenticación / Clave de API

Inicie sesión en el panel de control de Scrapeless y cree una clave de API. Exporte dicha clave antes de ejecutar los ejemplos:

export SCRAPELESS_API_KEY="YOUR_API_KEY"

Mantenga su clave de API en su entorno o gestor de secretos en lugar de incluirla en el control de versiones.

Inicio rápido

Guarde esto como main.go y ejecute go run . después de configurar su clave de API. Habilite cada servicio con la opción correspondiente With...() y cierre el cliente cuando termine.

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)
}

Matriz de cobertura de productos

Producto	Servicio del SDK	Habilitar con	Cobertura
Agent Browser	`client.Browser`	`scrapeless.WithBrowser()`	Cree y gestione sesiones de navegador remoto.
Perfiles de navegador	`client.Profile`	`scrapeless.WithProfile()`	Mantenga los datos del navegador entre sesiones.
Scraping API	`client.Scraping`	`scrapeless.WithScraping()`	Extraiga datos estructurados utilizando Actor de sitios web.
Web Unlocker	`client.Universal`	`scrapeless.WithUniversal()`	Recupere contenido de sitios web protegidos.
Crawl	`client.Crawl`	`scrapeless.WithCrawl()`	Extraiga una página o rastree un sitio web.
Google Search API	`client.DeepSerp`	`scrapeless.WithDeepSerp()`	Extraiga resultados de motores de búsqueda.
Proxies	`client.Proxy`	`scrapeless.WithProxy()`	Genere URLs de conexión de proxy.
AI Scraper	`client.AIScraper`	`scrapeless.WithAIScraper()`	Cree tareas de chat de IA y recupere su estado y resultados.

Los servicios son opcionales. Por ejemplo, inicialice el soporte para navegador e IA Scraper con scrapeless.New(scrapeless.WithBrowser(), scrapeless.WithAIScraper()). El README también documenta Client.Captcha, Client.Server, y Client.Router para flujos de trabajo adicionales.

Ejemplos de uso

Navegador

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)
}

Perfil de navegador

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)
}

Scraping API

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)
}

Web Unlocker

Extraiga datos de sitios web utilizando Web Unlocker (expuesto como client.Universal).

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)
}

Crawl

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)
}

Proxy

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)
}

AI Scraper

Extraiga contenido de chat de IA en masa para monitorear menciones de marca, comparar respuestas y analizar inteligencia competitiva de los modelos más recientes. Recupere URLs, indicaciones, respuestas en Markdown, citas y más a través de una sola integración.

Los Actor compatibles incluyen scraper.chatgpt, scraper.perplexity, scraper.copilot, scraper.gemini, scraper.aimode, scraper.overview, scraper.grok, y scraper.alexa. El JSON de input depende del actor; consulte la documentación de AI Scraper para parámetros detallados. El JSON opcional de webhook contiene un callback url.

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.
}

Ambos métodos devuelven el JSON de la API sin cambios. La creación devuelve task_id, status, y, cuando está disponible, task_result. La recuperación de resultados devuelve status, task_result cuando está disponible, y message en caso de error. El estado es success, failed, o running; el SDK no realiza sondeos automáticamente.

Las respuestas son bytes JSON sin procesar ([]byte), preservando todos los campos de la API. Descódalos con encoding/json según sea necesario.

Google Search API

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)
}

Para integraciones más completas, explore el directorio de ejemplos del repositorio.

Manejo de errores

Verifique el error devuelto antes de usar una respuesta de servicio. Utilice un plazo de contexto para limitar solicitudes individuales y defer client.Close() para liberar recursos del cliente.

Este ejemplo recupera una tarea existente de AI Scraper. Reemplace YOUR_TASK_ID con el ID devuelto por CreateTask.

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))
}

Los errores HTTP de AI Scraper devuelven un error. Una solicitud HTTP exitosa aún puede contener una tarea con status: "failed"; inspeccione los campos status y message de la respuesta después de descodificar el JSON.

Configuración / Variables de entorno

Se requiere la clave de API. Las sustituciones de endpoint son opcionales; la tabla muestra sus valores predeterminados.

Establezca las variables de entorno antes de iniciar el programa. El SDK también lee un archivo .env del directorio de trabajo. Las solicitudes de AI Scraper tienen un tiempo de espera HTTP de 30 segundos; use context.WithTimeout para un plazo más corto por solicitud.

Variable de entorno	Propósito / valor predeterminado
`SCRAPELESS_API_KEY`	Clave de API requerida del panel de control.
`SCRAPELESS_BASE_API_URL`	`https://api.scrapeless.com`
`SCRAPELESS_BROWSER_API_URL`	`https://browser.scrapeless.com`
`SCRAPELESS_CRAWL_API_URL`	`https://api.scrapeless.com`

Soporte

El SDK se publica bajo la licencia MIT.

Proyectos relacionados

Python SDK Descripción general