> ## Documentation Index
> Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Go

> El SDK de Firecrawl para Go es un wrapper de la API de Firecrawl que te permite convertir sitios web a Markdown fácilmente.

<Warning>
  Este SDK usa actualmente la versión **v1** de la API de Firecrawl, que no es la más reciente (v2 está disponible). Algunas funciones y mejoras podrían estar disponibles solo en v2.
</Warning>

<div id="installation">
  ## Instalación
</div>

Para instalar el SDK de Firecrawl para Go, puedes usar go get:

```bash Go theme={null}
go get github.com/mendableai/firecrawl-go
```

<div id="usage">
  ## Uso
</div>

1. Obtén una clave de API en [firecrawl.dev](https://firecrawl.dev)
2. Define la `API key` como parámetro en la estructura `FirecrawlApp`.
3. Define la `API URL` y/o pásala como parámetro a la estructura `FirecrawlApp`. De forma predeterminada es `https://api.firecrawl.dev`.
4. Define la `version` y/o pásala como parámetro a la estructura `FirecrawlApp`. De forma predeterminada es `v1`.

Aquí tienes un ejemplo de cómo usar el SDK con manejo de errores:

```go Go theme={null}
import (
	"fmt"
	"log"
	"github.com/google/uuid"
	"github.com/mendableai/firecrawl-go"
)

func ptr[T any](v T) *T {
	return &v
}

func main() {
	// Inicializa FirecrawlApp con tu clave de API
	apiKey := "fc-YOUR_API_KEY"
	apiUrl := "https://api.firecrawl.dev"
	version := "v1"

	app, err := firecrawl.NewFirecrawlApp(apiKey, apiUrl, version)
	if err != nil {
		log.Fatalf("Error al inicializar FirecrawlApp: %v", err)
	}

  // Realiza scraping de un sitio web
  scrapeStatus, err := app.ScrapeUrl("https://firecrawl.dev", firecrawl.ScrapeParams{
    Formats: []string{"markdown", "html"},
  })
  if err != nil {
    log.Fatalf("Error al enviar la solicitud de scraping: %v", err)
  }

  fmt.Println(scrapeStatus)

	// Realiza un rastreo (crawl) de un sitio web
  idempotencyKey := uuid.New().String() // clave de idempotencia opcional
  crawlParams := &firecrawl.CrawlParams{
		ExcludePaths: []string{"blog/*"},
		MaxDepth:     ptr(2),
	}

	crawlStatus, err := app.CrawlUrl("https://firecrawl.dev", crawlParams, &idempotencyKey)
	if err != nil {
		log.Fatalf("Error al enviar la solicitud de rastreo: %v", err)
	}

	fmt.Println(crawlStatus) 
}
```

<div id="scraping-a-url">
  ### Extracción de una URL
</div>

Para extraer una única URL con manejo de errores, usa el método `ScrapeURL`. Recibe la URL como parámetro y devuelve los datos extraídos como un diccionario.

```go Go theme={null}
// Extraer datos de un sitio web
scrapeResult, err := app.ScrapeUrl("https://firecrawl.dev", map[string]any{
  "formats": []string{"markdown", "html"},
})
if err != nil {
  log.Fatalf("Error al extraer la URL: %v", err)
}

fmt.Println(scrapeResult)
```

<div id="crawling-a-website">
  ### Rastreo de un sitio web
</div>

Para rastrear un sitio web, usa el método `CrawlUrl`. Recibe la URL inicial y parámetros opcionales como argumentos. El argumento `params` te permite especificar opciones adicionales para la tarea de rastreo, como el número máximo de páginas a rastrear, los dominios permitidos y el formato de salida.

```go Go theme={null}
crawlStatus, err := app.CrawlUrl("https://firecrawl.dev", map[string]any{
  "limit": 100,
  "scrapeOptions": map[string]any{
    "formats": []string{"markdown", "html"},
  },
})
if err != nil {
  log.Fatalf("No se pudo enviar la solicitud de rastreo: %v", err)
}

fmt.Println(crawlStatus) 
```

<div id="checking-crawl-status">
  ### Comprobar el estado del rastreo
</div>

Para comprobar el estado de un trabajo de rastreo, usa el método `CheckCrawlStatus`. Recibe el ID del trabajo como parámetro y devuelve el estado actual del rastreo.

```go Go theme={null}
// Obtener el estado del rastreo
crawlStatus, err := app.CheckCrawlStatus("<crawl_id>")

if err != nil {
  log.Fatalf("Error al obtener el estado del rastreo: %v", err)
}

fmt.Println(crawlStatus)
```

<div id="map-a-website">
  ### Mapear un sitio web
</div>

Usa `MapUrl` para generar una lista de URL de un sitio web. El argumento `params` te permite personalizar el proceso de mapeo, incluidas opciones para excluir subdominios o utilizar el sitemap.

```go Go theme={null}
// Mapear un sitio web
mapResult, err := app.MapUrl("https://firecrawl.dev", nil)
if err != nil {
  log.Fatalf("No se pudo mapear la URL: %v", err)
}

fmt.Println(mapResult)
```

<div id="error-handling">
  ## Gestión de errores
</div>

El SDK gestiona los errores que devuelve la API de Firecrawl y lanza las excepciones correspondientes. Si se produce un error durante una solicitud, se lanzará una excepción con un mensaje descriptivo.