# Interact après le scraping (/fr/features/interact)
Scrapez une page pour obtenir des données propres, puis appelez `/interact` pour commencer à effectuer des actions sur cette page : cliquer sur des boutons, remplir des formulaires, extraire du contenu dynamique ou naviguer plus en profondeur. Décrivez simplement ce que vous voulez faire, ou écrivez du code si vous avez besoin d’un contrôle total.
Prime : 5 000 crédits
pour des retours de qualité sur /interact
Pour être éligible, participez à un entretien approfondi (cas d'utilisation concrets et réfléchis, etc.) avec notre assistant de retours Firecrawl. Cela ne prend que quelques minutes, vous pouvez l'arrêter à tout moment et il est adapté aussi bien aux humains qu'aux agents (collez simplement le lien dans votre harness agentique !). Vous n'avez jamais utilisé /interact ? Votre avis compte quand même.
Démarrer l'entretien
Indiquez votre e-mail pour être éligible. La qualité des entretiens est évaluée à la fin de chaque semaine.
## Choisissez le bon modèle d’interaction [#choisissez-le-bon-modèle-dinteraction]
| Besoin | Utiliser | Documentation canonique |
| ------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Démarrer une session de navigateur autonome sans scraping préalable | Browser Sandbox / session Interact autonome | [Browser Sandbox](/fr/features/browser), [Créer une session de navigateur](/fr/api-reference/endpoint/browser-create), [Exécuter du code du navigateur](/fr/api-reference/endpoint/browser-execute), [Lister les sessions de navigateur](/fr/api-reference/endpoint/browser-list), [Supprimer une session de navigateur](/fr/api-reference/endpoint/browser-delete) |
| Continuer à partir d’un résultat de scraping avec `scrapeId` | Interact après le scraping | [Exécuter Interact](/fr/api-reference/endpoint/scrape-execute), [Arrêter Interact](/fr/api-reference/endpoint/scrape-browser-delete) |
Utilisez Interact lié au scraping lorsque le workflow commence par `POST /v2/scrape` et que la réponse inclut `data.metadata.scrapeId`. Utilisez Browser Sandbox lorsque vous avez besoin d’une session autonome avec son propre cycle de vie.
Décrivez l’action que vous souhaitez effectuer sur la page
Interagissez en toute sécurité via l’exécution de code avec playwright, agent-browser
Observez ou interagissez avec le browser en temps réel via un flux intégrable
## Comment ça fonctionne [#comment-ça-fonctionne]
1. **Scrape** une URL avec `POST /v2/scrape`. La réponse inclut un `scrapeId` dans `data.metadata.scrapeId`. Si vous souhaitez conserver l’état du navigateur, transmettez `profile` dans cette requête.
2. **Interact** en appelant `POST /v2/scrape/{scrapeId}/interact` avec un `prompt` ou du code `playwright`. Ne transmettez pas `profile` ici ; la session d’interaction hérite du profil de la tâche de scraping.
3. **Arrêtez** la session avec `DELETE /v2/scrape/{scrapeId}/interact` lorsque vous avez terminé. Pour les profils inscriptibles, les modifications sont enregistrées à l’arrêt de la session.
## Démarrage rapide [#démarrage-rapide]
Scrapez une page, interagissez avec elle, puis arrêtez la session :
Python
Node
cURL
CLI
```python
from firecrawl import Firecrawl
app = Firecrawl(
# Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
# api_key="fc-YOUR-API-KEY",
)
# 1. Scraper la page d'accueil d'Amazon
result = app.scrape("https://www.amazon.com", formats=["markdown"])
scrape_id = result.metadata.scrape_id
# 2. Interagir — rechercher un produit et obtenir son prix
app.interact(scrape_id, prompt="Search for iPhone 16 Pro Max")
response = app.interact(scrape_id, prompt="Click on the first result and tell me the price")
print(response.output)
# 3. Arrêter la session
app.stop_interaction(scrape_id)
```
```js
import { Firecrawl } from 'firecrawl';
const app = new Firecrawl({
// Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
// apiKey: 'fc-YOUR-API-KEY',
});
// 1. Scraper la page d'accueil d'Amazon
const result = await app.scrape('https://www.amazon.com', { formats: ['markdown'] });
const scrapeId = result.metadata?.scrapeId;
// 2. Interagir — rechercher un produit et obtenir son prix
await app.interact(scrapeId, { prompt: 'Search for iPhone 16 Pro Max' });
const response = await app.interact(scrapeId, { prompt: 'Click on the first result and tell me the price' });
console.log(response.output);
// 3. Arrêter la session
await app.stopInteraction(scrapeId);
```
```bash
# 1. Scraper la page d'accueil d'Amazon
# Aucune API key requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Content-Type: application/json" \
-d '{"url": "https://www.amazon.com", "formats": ["markdown"]}')
SCRAPE_ID=$(echo $RESPONSE | jq -r '.data.metadata.scrapeId')
# 2. Interagir — rechercher un produit et obtenir son prix
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"prompt": "Search for iPhone 16 Pro Max"}'
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"prompt": "Click on the first result and tell me the price"}'
# 3. Arrêter la session
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
```
```bash
# 1. Scrape la page d'accueil d'Amazon (l'ID de scrape est sauvegardé automatiquement)
firecrawl scrape https://www.amazon.com
# 2. Interagir — rechercher un produit et obtenir son prix
firecrawl interact "Search for iPhone 16 Pro Max"
firecrawl interact "Click on the first result and tell me the price"
# 3. Arrêter la session
firecrawl interact stop
```
```json title="Response"
{
"success": true,
"cdpUrl": "wss://browser.firecrawl.dev/...",
"liveViewUrl": "https://liveview.firecrawl.dev/...",
"interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
"output": "The iPhone 16 Pro Max (256GB) is priced at $1,199.00.",
"exitCode": 0,
"killed": false
}
```
## Interagir par prompt [#interagir-par-prompt]
La manière la plus simple d’interagir avec une page. Décrivez ce que vous voulez en langage naturel, et l’agent cliquera, saisira du texte, fera défiler la page et extraira automatiquement les données.
Python
Node
cURL
CLI
```python
response = app.interact(scrape_id, prompt="What are the customer reviews saying about battery life?")
print(response.output)
```
```js
const response = await app.interact(scrapeId, {
prompt: 'What are the customer reviews saying about battery life?',
});
console.log(response.output);
```
```bash
# Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{
"prompt": "What are the customer reviews saying about battery life?"
}'
```
```bash
firecrawl interact "What are the customer reviews saying about battery life?"
```
La réponse inclut un champ `output` avec la réponse de l’agent :
```json title="Response"
{
"success": true,
"cdpUrl": "wss://browser.firecrawl.dev/...",
"liveViewUrl": "https://liveview.firecrawl.dev/...",
"interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
"output": "Customers are generally positive about battery life. Most reviewers report 8-10 hours of use on a single charge. A few noted it drains faster with heavy multitasking.",
"stdout": "...",
"result": "...",
"stderr": "",
"exitCode": 0,
"killed": false
}
```
### Gardez les prompts courts et ciblés [#gardez-les-prompts-courts-et-ciblés]
Les prompts sont plus efficaces lorsque chacun correspond à **une tâche unique et claire**. Au lieu de demander à l'agent d'exécuter un workflow complexe en plusieurs étapes en une seule fois, décomposez-le en appels `interact` distincts. Chaque appel réutilise la même session de navigateur, de sorte que l'état est conservé d'un appel à l'autre.
## Exécution de code [#exécution-de-code]
Pour un contrôle total, vous pouvez exécuter du code directement dans le sandbox du navigateur. La variable `page` (un objet Playwright Page) est disponible en Node.js et en Python. Le mode Bash inclut [agent-browser](https://github.com/vercel-labs/agent-browser) en préinstallation. Vous pouvez également prendre des captures d’écran pendant la session : utilisez `(await page.screenshot()).toString("base64")` en Node.js, `await page.screenshot(path="/tmp/screenshot.png")` en Python, ou `agent-browser screenshot` en Bash.
### Node.js (Playwright) [#nodejs-playwright]
Le langage par défaut. Écrivez directement du code Playwright. `page` est déjà connectée au navigateur.
Python
Node
cURL
CLI
```python
response = app.interact(scrape_id, code="""
// Cliquer sur un bouton et attendre la navigation
await page.click('#next-page');
await page.waitForLoadState('networkidle');
// Extraire le contenu de la nouvelle page
const title = await page.title();
const content = await page.$eval('.article-body', el => el.textContent);
JSON.stringify({ title, content });
""")
print(response.result)
```
```js
const response = await app.interact(scrapeId, {
code: `
// Cliquer sur un bouton et attendre la navigation
await page.click('#next-page');
await page.waitForLoadState('networkidle');
// Extraire le contenu de la nouvelle page
const title = await page.title();
const content = await page.$eval('.article-body', el => el.textContent);
JSON.stringify({ title, content });
`,
});
console.log(response.result);
```
```bash
# Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{
"code": "await page.click(\"#next-page\"); await page.waitForLoadState(\"networkidle\"); const title = await page.title(); JSON.stringify({ title });",
"language": "node",
"timeout": 30
}'
```
```bash
# Utilise le dernier scrape automatiquement
firecrawl interact -c "
await page.click('#next-page');
await page.waitForLoadState('networkidle');
const title = await page.title();
const content = await page.\$eval('.article-body', el => el.textContent);
JSON.stringify({ title, content });
"
# Ou passer un ID de scrape explicitement
# firecrawl interact -c "await page.title()"
```
### Python [#python]
Définissez `language` sur `"python"` pour l’API Python de Playwright.
Python
Node
cURL
CLI
```python
response = app.interact(
scrape_id,
code="""
import json
await page.click('#load-more')
await page.wait_for_load_state('networkidle')
items = await page.query_selector_all('.item')
data = []
for item in items:
text = await item.text_content()
data.append(text.strip())
print(json.dumps(data))
""",
language="python",
)
print(response.stdout)
```
```js
const response = await app.interact(scrapeId, {
code: `
import json
await page.click('#load-more')
await page.wait_for_load_state('networkidle')
items = await page.query_selector_all('.item')
data = []
for item in items:
text = await item.text_content()
data.append(text.strip())
print(json.dumps(data))
`,
language: 'python',
});
console.log(response.stdout);
```
```bash
# Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{
"code": "import json\nawait page.click(\"#load-more\")\nawait page.wait_for_load_state(\"networkidle\")\nitems = await page.query_selector_all(\".item\")\ndata = [await i.text_content() for i in items]\nprint(json.dumps(data))",
"language": "python"
}'
```
```bash
firecrawl interact --python -c "
import json
await page.click('#load-more')
await page.wait_for_load_state('networkidle')
items = await page.query_selector_all('.item')
data = [await i.text_content() for i in items]
print(json.dumps(data))
"
```
### Bash (agent-browser) [#bash-agent-browser]
[agent-browser](https://github.com/vercel-labs/agent-browser) est une CLI préinstallée dans le sandbox avec plus de 60 commandes. Elle fournit un arbre d’accessibilité avec des références d’éléments (`@e1`, `@e2`, ...), ce qui est idéal pour l’automatisation pilotée par un LLM.
Python
Node
cURL
CLI
```python
# Prendre un instantané pour voir les éléments interactifs
snapshot = app.interact(
scrape_id,
code="agent-browser snapshot -i",
language="bash",
)
print(snapshot.stdout)
# Output :
# [document]
# @e1 [input type="text"] "Search..."
# @e2 [button] "Search"
# @e3 [link] "About"
# Interagir avec les éléments via les @refs
app.interact(
scrape_id,
code='agent-browser fill @e1 "firecrawl" && agent-browser click @e2',
language="bash",
)
```
```js
// Prendre un instantané pour voir les éléments interactifs
const snapshot = await app.interact(scrapeId, {
code: 'agent-browser snapshot -i',
language: 'bash',
});
console.log(snapshot.stdout);
// Output:
// [document]
// @e1 [input type="text"] "Search..."
// @e2 [button] "Search"
// @e3 [link] "About"
// Interagir avec les éléments en utilisant les @refs
await app.interact(scrapeId, {
code: 'agent-browser fill @e1 "firecrawl" && agent-browser click @e2',
language: 'bash',
});
```
```bash
# Prendre un instantané pour voir les éléments interactifs
# Aucune API key requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"code": "agent-browser snapshot -i", "language": "bash"}'
# Interagir avec les éléments en utilisant les @refs
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"code": "agent-browser fill @e1 \"firecrawl\" && agent-browser click @e2", "language": "bash"}'
```
```bash
# Prendre un instantané pour voir les éléments interactifs
firecrawl interact --bash -c "agent-browser snapshot -i"
# Interagir avec les éléments en utilisant les @refs
firecrawl interact --bash -c 'agent-browser fill @e1 "firecrawl" && agent-browser click @e2'
```
Commandes courantes d’agent-browser :
| Commande | Description |
| ------------------------- | -------------------------------------------------------- |
| `snapshot` | Arbre d’accessibilité complet avec références d’éléments |
| `snapshot -i` | Éléments interactifs uniquement |
| `click @e1` | Cliquer sur un élément par référence |
| `fill @e1 "text"` | Effacer le champ et saisir du texte |
| `type @e1 "text"` | Saisir sans effacer |
| `press Enter` | Appuyer sur une touche du clavier |
| `scroll down 500` | Faire défiler vers le bas de 500 pixels |
| `get text @e1` | obtenir le contenu du texte |
| `get url` | obtenir l’URL actuelle |
| `wait @e1` | Attendre un élément |
| `wait --load networkidle` | Attendre l’inactivité du réseau |
| `find text "X" click` | Trouver un élément par son texte et cliquer |
| `screenshot` | Prendre une capture d’écran de la page actuelle |
| `eval "js code"` | Exécuter du JavaScript dans la page |
## Vue en direct [#vue-en-direct]
Chaque réponse Interact renvoie un `liveViewUrl` que vous pouvez intégrer pour voir le navigateur en temps réel. Utile pour le débogage, les démonstrations ou la création d’interfaces pilotées par le navigateur.
```json title="Response"
{
"success": true,
"cdpUrl": "wss://browser.firecrawl.dev/...",
"liveViewUrl": "https://liveview.firecrawl.dev/...",
"interactiveLiveViewUrl": "https://liveview.firecrawl.dev/...",
"stdout": "",
"result": "...",
"exitCode": 0
}
```
```html
```
### Vue en direct interactive [#vue-en-direct-interactive]
La réponse inclut également un `interactiveLiveViewUrl`. Contrairement à la vue en direct standard, qui est en lecture seule, la vue en direct interactive permet aux utilisateurs de cliquer, de saisir du texte et d’interagir directement avec la session du navigateur via le flux intégré. Cela est utile pour créer des interfaces de navigateur destinées aux utilisateurs, par exemple pour des parcours de connexion ou des workflows guidés dans lesquels les utilisateurs finaux doivent contrôler le navigateur.
```html
```
### URL CDP [#url-cdp]
Chaque réponse Interact renvoie également un `cdpUrl` : l’URL WebSocket brute du protocole Chrome DevTools Protocol (CDP) pour la session de navigateur. Utilisez-la pour vous connecter directement à la session en cours depuis Playwright, Puppeteer ou n’importe quel client CDP, et piloter le navigateur avec votre propre code.
```js
import { chromium } from "playwright";
const browser = await chromium.connectOverCDP(cdpUrl);
const context = browser.contexts()[0];
const page = context.pages()[0];
```
## Cycle de vie d’une session [#cycle-de-vie-dune-session]
### Création [#création]
Le premier appel `POST /v2/scrape/{scrapeId}/interact` poursuit la session de scrape et démarre l’interaction.
### Réutilisation [#réutilisation]
Les appels `interact` suivants sur le même `scrapeId` réutilisent la session existante. Le navigateur reste ouvert et conserve son état entre les appels, ce qui vous permet d’enchaîner plusieurs interactions :
Python
Node
CLI
```python
# Premier appel : cliquer sur un onglet
app.interact(scrape_id, code="await page.click('#tab-2')")
# Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
result = app.interact(scrape_id, code="await page.$eval('#tab-2-content', el => el.textContent)")
print(result.result)
```
```js
// Premier appel : cliquer sur un onglet
await app.interact(scrapeId, { code: "await page.click('#tab-2')" });
// Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
const result = await app.interact(scrapeId, {
code: "await page.$eval('#tab-2-content', el => el.textContent)",
});
console.log(result.result);
```
```bash
# Premier appel : cliquer sur un onglet
firecrawl interact -c "await page.click('#tab-2')"
# Deuxième appel : l'onglet est toujours sélectionné, extraire son contenu
firecrawl interact -c "await page.\$eval('#tab-2-content', el => el.textContent)"
```
### Nettoyage [#nettoyage]
Arrêtez explicitement la session une fois terminé :
Python
Node
cURL
CLI
```python
app.stop_interaction(scrape_id)
```
```js
await app.stopInteraction(scrapeId);
```
```bash
# Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
```
```bash
# Arrête la dernière session de scrape
firecrawl interact stop
# Ou arrêter une session spécifique par ID
# firecrawl interact stop
```
Les sessions expirent également automatiquement en fonction du TTL (default : 10 minutes) ou du timeout d'inactivité (default : 5 minutes).
Arrêtez toujours les sessions une fois terminé afin d'éviter une facturation inutile. Les credits sont calculés au prorata à la seconde.
## Profils persistants avec Scrape + Interact [#profils-persistants-avec-scrape--interact]
Par défaut, chaque session de scrape + interact démarre avec un navigateur propre. Avec `profile`, vous pouvez enregistrer et réutiliser l’état du navigateur (cookies, localStorage, sessions) entre plusieurs scrapes. C’est utile pour rester connecté et conserver les préférences.
Passez l’objet `profile` dans la requête initiale `POST /v2/scrape`. Ne passez pas `profile` à `POST /v2/scrape/{scrapeId}/interact` ; la session interact réutilise la session de navigateur et les paramètres de profil de la tâche de scraping. Arrêtez la session interact avec `DELETE /v2/scrape/{scrapeId}/interact` afin que les modifications apportées au profil puissent être enregistrées.
```bash title="cURL"
curl -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer fc-YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com",
"formats": ["markdown"],
"profile": {
"name": "my-profile",
"saveChanges": true
}
}'
curl -X POST "https://api.firecrawl.dev/v2/scrape/SCRAPE_ID/interact" \
-H "Authorization: Bearer fc-YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Click the login button"
}'
curl -X DELETE "https://api.firecrawl.dev/v2/scrape/SCRAPE_ID/interact" \
-H "Authorization: Bearer fc-YOUR_API_KEY"
```
Le cycle de vie du profil est :
1. Créez le scrape avec `profile.name` et `saveChanges: true`.
2. Exécutez des interactions par prompt ou par code sur le `scrapeId` renvoyé.
3. Arrêtez la session pour enregistrer les cookies, le localStorage et les autres données d’état du navigateur.
4. Démarrez plus tard un scrape avec le même `profile.name`. Utilisez `saveChanges: false` lorsque vous voulez uniquement lire l’état existant sans réécrire les modifications.
Python
Node
cURL
CLI
```python
from firecrawl import Firecrawl
app = Firecrawl(
# Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
# api_key="fc-YOUR-API-KEY",
)
# Session 1 : Scrape avec un profil, connexion, puis arrêt (l'état est sauvegardé)
result = app.scrape(
"https://app.example.com/login",
formats=["markdown"],
profile={"name": "my-app", "save_changes": True},
)
scrape_id = result.metadata.scrape_id
app.interact(scrape_id, prompt="Fill in user@example.com and password, then click Login")
app.stop_interaction(scrape_id)
# Session 2 : Scrape avec le même profil en mode lecture seule — déjà connecté
result = app.scrape(
"https://app.example.com/dashboard",
formats=["markdown"],
profile={"name": "my-app", "save_changes": False},
)
scrape_id = result.metadata.scrape_id
response = app.interact(scrape_id, prompt="Extract the dashboard data")
print(response.output)
app.stop_interaction(scrape_id)
```
```js
import { Firecrawl } from 'firecrawl';
const app = new Firecrawl({
// Aucune clé API requise pour démarrer — ajoutez-en une pour des limites de débit plus élevées :
// apiKey: 'fc-YOUR-API-KEY',
});
// Session 1 : Scrape avec un profil, connexion, puis arrêt (l'état est sauvegardé)
const result1 = await app.scrape('https://app.example.com/login', {
formats: ['markdown'],
profile: { name: 'my-app', saveChanges: true },
});
const scrapeId1 = result1.metadata?.scrapeId;
await app.interact(scrapeId1, { prompt: 'Fill in user@example.com and password, then click Login' });
await app.stopInteraction(scrapeId1);
// Session 2 : Scrape avec le même profil en mode lecture seule — déjà connecté
const result2 = await app.scrape('https://app.example.com/dashboard', {
formats: ['markdown'],
profile: { name: 'my-app', saveChanges: false },
});
const scrapeId2 = result2.metadata?.scrapeId;
const response = await app.interact(scrapeId2, { prompt: 'Extract the dashboard data' });
console.log(response.output);
await app.stopInteraction(scrapeId2);
```
```bash
# Session 1: Scrape with a profile
# Aucune clé API requise pour démarrer — ajoutez -H "Authorization: Bearer $FIRECRAWL_API_KEY" pour des limites de débit plus élevées :
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Content-Type: application/json" \
-d '{
"url": "https://app.example.com/login",
"formats": ["markdown"],
"profile": { "name": "my-app", "saveChanges": true }
}')
SCRAPE_ID=$(echo $RESPONSE | jq -r '.data.metadata.scrapeId')
# Log in via interact
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"prompt": "Fill in user@example.com and password, then click Login"}'
# Arrêt — l'état est sauvegardé dans le profil
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
# Session 2 : Scrape à nouveau avec le même profil en mode lecture seule — déjà connecté
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Content-Type: application/json" \
-d '{
"url": "https://app.example.com/dashboard",
"formats": ["markdown"],
"profile": { "name": "my-app", "saveChanges": false }
}')
SCRAPE_ID=$(echo $RESPONSE | jq -r '.data.metadata.scrapeId')
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Content-Type: application/json" \
-d '{"prompt": "Extract the dashboard data"}'
```
```bash
# Session 1 : Scrape avec un profil, connexion, puis arrêt (l'état est sauvegardé)
firecrawl scrape https://app.example.com/login --profile my-app
firecrawl interact "Fill in user@example.com and password, then click Login"
firecrawl interact stop
# Session 2 : Scrape avec le même profil — déjà connecté
firecrawl scrape https://app.example.com/dashboard --profile my-app
firecrawl interact "Extract the dashboard data"
firecrawl interact stop
# Lecture seule : charger l'état du profil sans sauvegarder les modifications
firecrawl scrape https://app.example.com/dashboard --profile my-app --no-save-changes
```
| Paramètre | Par défaut | Description |
| ------------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` | None | Nom du profil persistant. Les scrapes portant le même nom partagent l’état du navigateur. |
| `saveChanges` | `true` | Lorsque `true`, l’état du navigateur est réenregistré dans le profil à l’arrêt de la session interact. Définissez `false` pour charger des données existantes sans les écrire, ce qui est utile lorsque vous avez besoin de plusieurs lecteurs concurrents. |
Une seule session peut enregistrer dans un profil à la fois. Si une autre session enregistre déjà, vous recevrez une erreur `409`. Vous pouvez quand même ouvrir le même profil avec `saveChanges: false`, ou réessayer plus tard.
L’état du navigateur est enregistré lorsque la session interact est arrêtée. Arrêtez toujours la session une fois terminé afin que le profil puisse être réutilisé.
### Vérifier la persistance [#vérifier-la-persistance]
Vous pouvez tester la persistance sans dépendre d’une véritable procédure de connexion en écrivant une valeur dans `localStorage` lors d’une session, en l’arrêtant, puis en lisant cette valeur dans une seconde session avec le même profil.
```bash title="cURL"
# Session 1 : écrire l'état du navigateur et le sauvegarder
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com",
"formats": ["markdown"],
"profile": { "name": "profile-validation", "saveChanges": true }
}')
SCRAPE_ID=$(echo "$RESPONSE" | jq -r ".data.metadata.scrapeId")
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"code": "await page.evaluate(() => { localStorage.setItem(\"firecrawlProfileCheck\", \"saved\"); document.cookie = \"firecrawl_profile_check=saved; path=/; max-age=3600\"; return localStorage.getItem(\"firecrawlProfileCheck\"); });"
}'
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY"
# Session 2 : charger le même profil en mode lecture seule et vérifier la valeur
RESPONSE=$(curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com",
"formats": ["markdown"],
"profile": { "name": "profile-validation", "saveChanges": false }
}')
SCRAPE_ID=$(echo "$RESPONSE" | jq -r ".data.metadata.scrapeId")
curl -s -X POST "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"code": "await page.evaluate(() => ({ localStorage: localStorage.getItem(\"firecrawlProfileCheck\"), cookie: document.cookie.includes(\"firecrawl_profile_check=saved\") }));"
}'
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY"
```
La deuxième réponse Interact devrait afficher `localStorage` avec la valeur `"saved"` et `cookie` avec la valeur `true`.
Les profils créés via l’API peuvent ne pas encore apparaître dans Dashboard > Interact > Profiles. Le dashboard ne fournit pas encore un inventaire complet des profils persistants créés via l’API.
## Quand utiliser chaque option [#quand-utiliser-chaque-option]
| Cas d’usage | Recommandé | Pourquoi |
| ------------------------------------------------- | -------------------------------- | -------------------------------------------- |
| Recherche web | [Recherche](/fr/features/search) | Point de terminaison de recherche dédié |
| Obtenir du contenu propre depuis une URL | [Scrape](/fr/features/scrape) | Un seul appel API, aucune session nécessaire |
| Cliquer, saisir, naviguer sur une page | **Interact** (prompt) | Décrivez simplement l’action en anglais |
| Extraire des données nécessitant des interactions | **Interact** (prompt) | Aucun sélecteur nécessaire |
| Logique de scraping complexe | **Interact** (code) | Contrôle total avec Playwright |
**Interact vs Browser Sandbox** : Interact repose sur la même infrastructure que [Browser Sandbox](/fr/features/browser), mais offre une meilleure interface pour le cas le plus courant : scraper une page, puis aller plus loin. Browser Sandbox est préférable lorsque vous avez besoin d’une session de navigateur autonome qui n’est pas liée à un scraping spécifique.
## Tarification [#tarification]
* **Code uniquement** (sans `prompt`): 2 credits par minute de session
* **Avec des prompts IA**: 7 credits par minute de session
* **Scrape**: facturé séparément (1 credit par scrape, plus les coûts spécifiques au format)
## Référence de l’API [#référence-de-lapi]
* [Exécuter Interact](/fr/api-reference/endpoint/scrape-execute): `POST /v2/scrape/{scrapeId}/interact`
* [Arrêter Interact](/fr/api-reference/endpoint/scrape-browser-delete): `DELETE /v2/scrape/{scrapeId}/interact`
### Corps de la requête (POST) [#corps-de-la-requête-post]
| Champ | Type | Par défaut | Description |
| ---------- | -------- | ---------- | ---------------------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Aucune | Tâche en langage naturel pour l’agent d’IA. Obligatoire si `code` n’est pas défini. Maximum 10 000 caractères. |
| `code` | `string` | Aucune | Code à exécuter (Node.js, Python ou Bash). Obligatoire si `prompt` n’est pas défini. Maximum 100 000 caractères. |
| `language` | `string` | `"node"` | `"node"`, `"python"` ou `"bash"`. Utilisé uniquement avec `code`. |
| `timeout` | `number` | `30` | timeout en secondes (1–300). |
| `origin` | `string` | Aucune | Identifiant de l’appelant pour le suivi de l’activité. |
### Réponse [#réponse]
| Champ | Description |
| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `success` | `true` si l’exécution s’est terminée sans erreur |
| `cdpUrl` | URL WebSocket brute du Chrome DevTools Protocol (CDP) pour la session de navigateur. Connectez-vous directement avec Playwright, Puppeteer ou n’importe quel client CDP |
| `liveViewUrl` | URL de la vue en direct en lecture seule pour la session de navigateur |
| `interactiveLiveViewUrl` | URL de la vue en direct interactive (les utilisateurs peuvent contrôler le navigateur) |
| `output` | La réponse en langage naturel de l’agent à votre `prompt`. Présent uniquement lors de l’utilisation de `prompt`. |
| `stdout` | Sortie standard de l’exécution du code |
| `result` | Valeur de retour brute du sandbox. Pour `code` : la dernière expression évaluée. Pour `prompt` : l’instantané brut de la page utilisé par l’agent pour produire `output`. |
| `stderr` | Sortie d’erreur standard |
| `exitCode` | Code de sortie (`0` = succès) |
| `killed` | `true` si l’exécution a été interrompue en raison d’un timeout |
***
Vous avez des retours ou besoin d’aide ? Envoyez un e-mail à [help@firecrawl.com](mailto:help@firecrawl.com) ou contactez-nous sur [Discord](https://discord.gg/firecrawl).