> ## Documentation Index
> Fetch the complete documentation index at: https://firecrawl-claude-eager-dijkstra-dne9il.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Elixir

> Le SDK Elixir de Firecrawl est un client auto-généré pour l’API v2 de Firecrawl, conçu avec Req et NimbleOptions.

Scrapez des pages individuelles, effectuez le crawl de sites entiers et la cartographie d’URL depuis votre application Elixir. Le SDK valide tous les paramètres à l’exécution avec NimbleOptions et utilise Req pour les requêtes HTTP, afin que vous obteniez des erreurs claires en cas de faute de frappe ou d’option invalide avant même qu’une requête ne soit envoyée.

Chaque fonction dispose d’une variante bang (`!`) qui lève une exception au lieu de renvoyer des tuples `{:error, ...}`.

<div id="installation">
  ## Installation
</div>

Ajoutez `firecrawl` à votre liste de dépendances dans `mix.exs` et configurez votre clé API :

```elixir Elixir theme={null}
# Ajouter à mix.exs
{:firecrawl, "~> 1.0"}

# Ensuite, configurez votre clé API dans config.exs
config :firecrawl, api_key: "fc-YOUR-API-KEY"
```

Ou transmettez la clé API à chaque requête :

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

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

1. Obtenez une clé API sur [firecrawl.dev](https://firecrawl.dev)
2. Définissez la clé API dans la configuration de votre application ou passez-la en option à n’importe quelle fonction.

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

# Crawler un site 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">
  ### Scraper une URL
</div>

Scrapez une seule URL avec `scrape_and_extract_from_url`. Cette fonction renvoie le contenu de la page sous forme de données structurées, y compris le markdown, les métadonnées et tous les autres formats demandés.

```elixir Elixir theme={null}
# Scraper un site 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">
  ### Effectuer le crawl d’un site web
</div>

Pour effectuer le crawl d’un site web, utilisez `crawl_urls`. Cette méthode prend l’URL de départ ainsi que des paramètres facultatifs, tels que la limite de pages, les domaines autorisés et le format de sortie.

```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">
  ### Démarrer un crawl
</div>

Démarrez une tâche de crawl et obtenez l’ID de tâche sans bloquer :

```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">
  ### Vérifier l’état d’un crawl
</div>

Vérifiez l’état d’une tâche de crawl avec `get_crawl_status` :

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

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

Annulez une tâche de crawl avec `cancel_crawl` :

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

<div id="map-a-website">
  ### Cartographier un site web
</div>

Utilisez `map_urls` pour générer une liste d’URL d’un site web :

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

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

Recherchez sur le web et scrapez éventuellement les résultats :

```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">
  ### Extraction par lot
</div>

Extrayez plusieurs URL en un seul lot :

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

Démarrez une tâche d’extraction de données pilotée par un agent :

```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"]

# Interroger l'état
{:ok, status} = Firecrawl.get_agent_status(job_id)
IO.inspect(status.body)
```

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

Démarrez des sessions de navigateur dans le cloud et exécutez du code à distance.

<div id="create-a-session">
  ### Créer une session
</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">
  ### Exécuter du code
</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">
  ### Profils
</div>

Enregistrez et réutilisez l’état du navigateur (cookies, localStorage, etc.) d’une session à l’autre :

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

<div id="list-close-sessions">
  ### Lister & fermer des sessions
</div>

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

# Fermer une session
{:ok, _} = Firecrawl.delete_browser_session(session_id)
```

<div id="self-hosted-instances">
  ## Instances autohébergées
</div>

Pour utiliser une instance autohébergée de Firecrawl, passez l’option `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">
  ## Gestion des erreurs
</div>

Les fonctions sans bang renvoient `{:ok, response}` ou `{:error, exception}`. Les variantes bang déclenchent une exception en cas d’erreur. NimbleOptions valide tous les paramètres avant l’envoi de la requête, ce qui permet de détecter immédiatement les fautes de frappe, les champs obligatoires manquants et les erreurs de type.

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

# Ou utiliser la variante bang pour lever une exception en cas d'erreur :
response = Firecrawl.scrape_and_extract_from_url!(url: "https://example.com")
IO.inspect(response.body)
```

<div id="all-available-functions">
  ## Toutes les fonctions disponibles
</div>

| Fonction                       | Description                                       |
| ------------------------------ | ------------------------------------------------- |
| `scrape_and_extract_from_url`  | Scraper une seule URL                             |
| `scrape_and_extract_from_urls` | Effectuer une extraction par lot de plusieurs URL |
| `crawl_urls`                   | Effectuer le crawl d’un site web                  |
| `get_crawl_status`             | Vérifier l’état d’une tâche de crawl              |
| `get_crawl_errors`             | Obtenir les erreurs d’une tâche de crawl          |
| `get_active_crawls`            | Lister les crawls actifs                          |
| `cancel_crawl`                 | Annuler une tâche de crawl                        |
| `map_urls`                     | Cartographier les URL d’un site web               |
| `search_and_scrape`            | Rechercher et scraper les résultats               |
| `start_agent`                  | Démarrer une tâche d’extraction avec un agent     |
| `get_agent_status`             | Vérifier l’état d’une tâche d’agent               |
| `cancel_agent`                 | Annuler une tâche d’agent                         |
| `create_browser_session`       | Créer une session de navigateur                   |
| `execute_browser_code`         | Exécuter du code dans une session de navigateur   |
| `list_browser_sessions`        | Lister les sessions de navigateur                 |
| `delete_browser_session`       | Supprimer une session de navigateur               |
| `get_batch_scrape_status`      | Vérifier l’état d’une extraction par lot          |
| `get_batch_scrape_errors`      | Obtenir les erreurs d’une extraction par lot      |
| `cancel_batch_scrape`          | Annuler une extraction par lot                    |
| `get_credit_usage`             | Obtenir les crédits restants                      |

Chaque fonction ci-dessus possède une variante avec bang (`!`) (par exemple, `scrape_and_extract_from_url!`) qui lève une erreur au lieu de renvoyer des tuples d’erreur.

Pour la documentation complète de l’API, consultez [hexdocs.pm/firecrawl](https://hexdocs.pm/firecrawl).