> ## Documentation Index
> Fetch the complete documentation index at: https://docs.firecrawl.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Elixir

> El SDK de Firecrawl para Elixir es un cliente autogenerado para la API v2 de Firecrawl, desarrollado con Req y NimbleOptions.

Haz scraping de páginas individuales, rastrea sitios completos y mapea URL desde tu aplicación de Elixir. El SDK valida todos los parámetros en tiempo de ejecución con NimbleOptions y usa Req para HTTP, así que obtienes errores claros por errores tipográficos y opciones no válidas antes de realizar cualquier solicitud.

Cada función tiene una variante con bang (`!`) que lanza una excepción en lugar de devolver tuplas `{:error, ...}`.

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

Añade `firecrawl` a tu lista de dependencias en `mix.exs` y configura tu clave de API:

```elixir Elixir theme={null}
# Añadir a mix.exs
{:firecrawl, "~> 1.0"}

# Luego configura tu API key en config.exs
config :firecrawl, api_key: "fc-YOUR-API-KEY"
```

O pasa la clave de API en cada solicitud:

```elixir Elixir theme={null}
Firecrawl.scrape_and_extract_from_url([url: "https://example.com"], api_key: "fc-YOUR-API-KEY")
```

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

1. Obtén una clave de API en [firecrawl.dev](https://firecrawl.dev)
2. Configura la clave de API en tu aplicación o pásala como opción a cualquier función.

```elixir Elixir theme={null}
# Hacer scraping de un sitio web:
{:ok, scrape_result} = Firecrawl.scrape_and_extract_from_url(
  url: "https://firecrawl.dev",
  formats: ["markdown", "html"]
)
IO.inspect(scrape_result.body)

# Rastrear un sitio web:
{:ok, crawl_result} = Firecrawl.crawl_urls(
  url: "https://firecrawl.dev",
  limit: 100,
  scrape_options: [
    formats: ["markdown", "html"]
  ]
)
IO.inspect(crawl_result.body)
```

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

Haz scraping de una URL con `scrape_and_extract_from_url`. Devuelve el contenido de la página como datos estructurados, incluidos markdown, metadatos y cualquier otro formato que solicites.

```elixir Elixir theme={null}
# Hacer scraping de un sitio web:
{:ok, result} = Firecrawl.scrape_and_extract_from_url(url: "https://firecrawl.dev", formats: ["markdown", "html"])
IO.inspect(result.body)
```

<div id="crawl-a-website">
  ### Rastrear un sitio web
</div>

Para rastrear un sitio web, usa `crawl_urls`. Recibe la URL inicial y parámetros opcionales, como el límite de páginas, los dominios permitidos y el formato de salida.

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.crawl_urls(url: "https://docs.firecrawl.dev", limit: 5)
IO.inspect(result.body)
```

<div id="start-a-crawl">
  ### Iniciar un rastreo
</div>

Inicia un trabajo de rastreo y devuelve el ID del trabajo sin bloquear:

```elixir Elixir theme={null}
{:ok, job} = Firecrawl.crawl_urls(url: "https://docs.firecrawl.dev", limit: 10)
crawl_id = job.body["id"]
IO.puts(crawl_id)
```

<div id="checking-crawl-status">
  ### Consultar el estado de un rastreo
</div>

Consulta el estado de un trabajo de rastreo con `get_crawl_status`:

```elixir Elixir theme={null}
{:ok, status} = Firecrawl.get_crawl_status("<crawl-id>")
IO.inspect(status.body)
```

<div id="cancelling-a-crawl">
  ### Cancelar un rastreo
</div>

Cancela un trabajo de rastreo con `cancel_crawl`:

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.cancel_crawl("<crawl-id>")
IO.puts("Cancelled: #{inspect(result.body)}")
```

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

Usa `map_urls` para generar una lista de URL de un sitio web:

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.map_urls(url: "https://firecrawl.dev", limit: 10)
IO.inspect(result.body)
```

<div id="search">
  ### Buscar
</div>

Busca en la web y, opcionalmente, haz scraping de los resultados:

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.search_and_scrape(query: "firecrawl web scraping", limit: 5)
IO.inspect(result.body["data"]["web"])
```

<div id="batch-scrape">
  ### Extracción por lotes
</div>

Haz scraping de varias URL en un único trabajo por lotes:

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.scrape_and_extract_from_urls(
  urls: ["https://firecrawl.dev", "https://docs.firecrawl.dev"],
  formats: ["markdown"]
)
IO.inspect(result.body)
```

<div id="agent">
  ### Agent
</div>

Inicia una tarea de extracción de datos con agentes:

```elixir Elixir theme={null}
{:ok, job} = Firecrawl.start_agent(
  prompt: "Extract all product names and prices",
  urls: ["https://example.com/products"]
)
job_id = job.body["id"]

# Consultar el estado
{:ok, status} = Firecrawl.get_agent_status(job_id)
IO.inspect(status.body)
```

<div id="browser">
  ## Browser
</div>

Inicia sesiones de navegador en la nube y ejecuta código de forma remota.

<div id="create-a-session">
  ### Crear una sesión
</div>

```elixir Elixir theme={null}
{:ok, session} = Firecrawl.create_browser_session(ttl: 600)
session_id = session.body["id"]
cdp_url = session.body["cdpUrl"]
live_view_url = session.body["liveViewUrl"]
```

<div id="execute-code">
  ### Ejecutar código
</div>

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.execute_browser_code(session_id,
  code: ~s(await page.goto("https://news.ycombinator.com")\ntitle = await page.title()\nprint(title)),
  language: "python"
)
IO.inspect(result.body)
```

<div id="profiles">
  ### Perfiles
</div>

Guarda y reutiliza el estado del navegador (cookies, localStorage, etc.) entre sesiones:

```elixir Elixir theme={null}
{:ok, session} = Firecrawl.create_browser_session(
  ttl: 600,
  profile: [
    name: "my-profile",
    save_changes: true
  ]
)
```

<div id="list-close-sessions">
  ### Listar & cerrar sesiones
</div>

```elixir Elixir theme={null}
# Listar sesiones activas
{:ok, sessions} = Firecrawl.list_browser_sessions(status: "active")
IO.inspect(sessions.body)

# Cerrar una sesión
{:ok, _} = Firecrawl.delete_browser_session(session_id)
```

<div id="self-hosted-instances">
  ## Instancias autogestionadas
</div>

Para usar una instancia autogestionada de Firecrawl, pasa la opción `base_url`:

```elixir Elixir theme={null}
{:ok, result} = Firecrawl.scrape_and_extract_from_url(
  [url: "https://example.com"],
  base_url: "https://your-instance.com/v2"
)
```

<div id="error-handling">
  ## Manejo de errores
</div>

Las funciones sin bang devuelven `{:ok, response}` o `{:error, exception}`. Las variantes con bang lanzan una excepción en caso de error. NimbleOptions valida todos los parámetros antes de enviar la solicitud, detectando de inmediato errores tipográficos, campos obligatorios ausentes y errores de tipo.

```elixir Elixir theme={null}
case Firecrawl.scrape_and_extract_from_url(url: "https://example.com") do
  {:ok, response} -> IO.inspect(response.body)
  {:error, error} -> IO.puts("Error: #{Exception.message(error)}")
end

# O usar la variante bang para lanzar un error:
response = Firecrawl.scrape_and_extract_from_url!(url: "https://example.com")
IO.inspect(response.body)
```

<div id="all-available-functions">
  ## Todas las funciones disponibles
</div>

| Función                        | Descripción                                    |
| ------------------------------ | ---------------------------------------------- |
| `scrape_and_extract_from_url`  | Hace scraping de una sola URL                  |
| `scrape_and_extract_from_urls` | Realiza una extracción por lotes de varias URL |
| `crawl_urls`                   | Rastrea un sitio web                           |
| `get_crawl_status`             | Comprueba el estado del trabajo de rastreo     |
| `get_crawl_errors`             | Obtiene los errores del trabajo de rastreo     |
| `get_active_crawls`            | Lista los rastreos activos                     |
| `cancel_crawl`                 | Cancela un trabajo de rastreo                  |
| `map_urls`                     | Mapea las URL de un sitio web                  |
| `search_and_scrape`            | Busca y hace scraping de los resultados        |
| `start_agent`                  | Inicia una tarea de extracción con agente      |
| `get_agent_status`             | Comprueba el estado del trabajo del agente     |
| `cancel_agent`                 | Cancela un trabajo del agente                  |
| `create_browser_session`       | Crea una sesión del navegador                  |
| `execute_browser_code`         | Ejecuta código en una sesión del navegador     |
| `list_browser_sessions`        | Lista las sesiones del navegador               |
| `delete_browser_session`       | Elimina una sesión del navegador               |
| `get_batch_scrape_status`      | Comprueba el estado de la extracción por lotes |
| `get_batch_scrape_errors`      | Obtiene los errores de la extracción por lotes |
| `cancel_batch_scrape`          | Cancela una extracción por lotes               |
| `get_credit_usage`             | Obtiene los créditos restantes                 |

Todas las funciones anteriores tienen una variante bang (`!`) (por ejemplo, `scrape_and_extract_from_url!`) que lanza una excepción en lugar de devolver tuplas de error.

Para consultar la documentación completa de la API, consulta [hexdocs.pm/firecrawl](https://hexdocs.pm/firecrawl).