> ## 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

> O Firecrawl Go SDK é um wrapper da API do Firecrawl que ajuda você a transformar sites em Markdown com facilidade.

<Warning>
  Este SDK atualmente usa a versão **v1** da API do Firecrawl, que não é a mais recente (a v2 está disponível). Alguns recursos e melhorias podem estar disponíveis apenas na v2.
</Warning>

<div id="installation">
  ## Instalação
</div>

Para instalar o SDK do Firecrawl para Go, use o go get:

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

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

1. Obtenha uma chave de API em [firecrawl.dev](https://firecrawl.dev)
2. Defina a `API key` como parâmetro na struct `FirecrawlApp`.
3. Defina a `API URL` e/ou passe-a como parâmetro na struct `FirecrawlApp`. O padrão é `https://api.firecrawl.dev`.
4. Defina a `version` e/ou passe-a como parâmetro na struct `FirecrawlApp`. O padrão é `v1`.

Veja um exemplo de como usar o SDK com tratamento de erros:

```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() {
	// Inicialize o FirecrawlApp com sua chave 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("Falha ao inicializar o FirecrawlApp: %v", err)
	}

  // Faça o scraping de um site
  scrapeStatus, err := app.ScrapeUrl("https://firecrawl.dev", firecrawl.ScrapeParams{
    Formats: []string{"markdown", "html"},
  })
  if err != nil {
    log.Fatalf("Falha ao enviar a solicitação de scraping: %v", err)
  }

  fmt.Println(scrapeStatus)

	// Faça o crawling de um site
  idempotencyKey := uuid.New().String() // chave de idempotência opcional
  crawlParams := &firecrawl.CrawlParams{
		ExcludePaths: []string{"blog/*"},
		MaxDepth:     ptr(2),
	}

	crawlStatus, err := app.CrawlUrl("https://firecrawl.dev", crawlParams, &idempotencyKey)
	if err != nil {
		log.Fatalf("Falha ao enviar a solicitação de crawling: %v", err)
	}

	fmt.Println(crawlStatus) 
}
```

<div id="scraping-a-url">
  ### Scraping de uma URL
</div>

Para extrair uma única URL com tratamento de erros, use o método `ScrapeURL`. Ele recebe a URL como parâmetro e retorna os dados extraídos como um dicionário.

```go Go theme={null}
// Raspar um site
scrapeResult, err := app.ScrapeUrl("https://firecrawl.dev", map[string]any{
  "formats": []string{"markdown", "html"},
})
if err != nil {
  log.Fatalf("Falha ao raspar a URL: %v", err)
}

fmt.Println(scrapeResult)
```

<div id="crawling-a-website">
  ### Rastreamento de um site
</div>

Para rastrear um site, use o método `CrawlUrl`. Ele recebe a URL inicial e parâmetros opcionais. O parâmetro `params` permite especificar opções adicionais para a tarefa de rastreamento, como o número máximo de páginas a rastrear, domínios permitidos e o formato de saída.

```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("Falha ao enviar a solicitação de crawl: %v", err)
}

fmt.Println(crawlStatus) 
```

<div id="checking-crawl-status">
  ### Verificando o status do crawl
</div>

Para verificar o status de um job de crawl, use o método `CheckCrawlStatus`. Ele recebe o ID do job como parâmetro e retorna o status atual do job de crawl.

```go Go theme={null}
// Obter status do crawl
crawlStatus, err := app.CheckCrawlStatus("<crawl_id>")

if err != nil {
  log.Fatalf("Falha ao obter o status do crawl: %v", err)
}

fmt.Println(crawlStatus)
```

<div id="map-a-website">
  ### Mapear um site
</div>

Use `MapUrl` para gerar uma lista de URLs de um site. O argumento `params` permite personalizar o processo de mapeamento, incluindo opções para excluir subdomínios ou usar o sitemap.

```go Go theme={null}
// Mapear um site
mapResult, err := app.MapUrl("https://firecrawl.dev", nil)
if err != nil {
  log.Fatalf("Falha ao mapear a URL: %v", err)
}

fmt.Println(mapResult)
```

<div id="error-handling">
  ## Tratamento de erros
</div>

O SDK trata os erros retornados pela API do Firecrawl e lança as exceções apropriadas. Se ocorrer um erro durante uma requisição, uma exceção será lançada com uma mensagem de erro descritiva.