# Interact tras el scraping (/es/features/interact)
Haz scraping de una página para obtener datos limpios y luego llama a `/interact` para empezar a realizar acciones en esa página: hacer clic en botones, completar formularios, extraer contenido dinámico o navegar más a fondo. Solo describe lo que quieres hacer, o escribe código si necesitas un control total.
Recompensa: 5000 créditos
por comentarios útiles sobre /interact
Para optar a la recompensa, completa una entrevista con información relevante (casos de uso concretos y bien pensados, etc.) con nuestro Asistente de Feedback de Firecrawl. Solo toma unos minutos, puedes detenerla en cualquier momento y es apta tanto para personas como para agentes (¡solo pega el enlace en tu entorno de agentes!). ¿Nunca usaste /interact? Tu opinión también cuenta.
Iniciar la entrevista
Incluye tu correo electrónico para poder optar a la recompensa. La calidad de las entrevistas se revisa al final de cada semana.
## Selecciona el modelo de interacción adecuado [#selecciona-el-modelo-de-interacción-adecuado]
| Necesidad | Usar | Documentación canónica |
| -------------------------------------------------------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Iniciar una sesión de browser independiente sin hacer scraping antes | Browser Sandbox / sesión independiente de Interact | [Browser Sandbox](/es/features/browser), [Crear sesión de browser](/es/api-reference/endpoint/browser-create), [Ejecutar código en el browser](/es/api-reference/endpoint/browser-execute), [Listar sesiones de browser](/es/api-reference/endpoint/browser-list), [Eliminar sesión de browser](/es/api-reference/endpoint/browser-delete) |
| Continuar desde un resultado de scraping usando `scrapeId` | Interact tras el scraping | [Ejecutar Interact](/es/api-reference/endpoint/scrape-execute), [Detener Interact](/es/api-reference/endpoint/scrape-browser-delete) |
Usa Interact vinculado al scraping cuando el flujo de trabajo comienza con `POST /v2/scrape` y la respuesta incluye `data.metadata.scrapeId`. Usa Browser Sandbox cuando necesites una sesión independiente con su propio ciclo de vida.
Describe qué acción quieres realizar en la página
Interactúa de forma segura mediante la ejecución de código con playwright, agent-browser
Observa o interactúa con el browser en tiempo real mediante un stream incrustable
## Cómo funciona [#cómo-funciona]
1. **Haz scraping de** una URL con `POST /v2/scrape`. La respuesta incluye un `scrapeId` en `data.metadata.scrapeId`. Si quieres conservar el estado del navegador, pasa `profile` en esta solicitud.
2. **Interactúa** llamando a `POST /v2/scrape/{scrapeId}/interact` con un `prompt` o con código de Playwright `code`. No pases `profile` aquí; la sesión de interacción hereda el perfil del trabajo de scraping.
3. **Detén** la sesión con `DELETE /v2/scrape/{scrapeId}/interact` cuando hayas terminado. En los perfiles con escritura, los cambios se guardan cuando la sesión se detiene.
## Inicio rápido [#inicio-rápido]
Haz scraping de una página, interactúa con ella y detén la sesión:
Python
Node
cURL
CLI
```python
from firecrawl import Firecrawl
app = Firecrawl(
# No se necesita API key para comenzar — añade una para límites de tasa más altos:
# api_key="fc-YOUR-API-KEY",
)
# 1. Extraer la página principal de Amazon
result = app.scrape("https://www.amazon.com", formats=["markdown"])
scrape_id = result.metadata.scrape_id
# 2. Interactuar — buscar un producto y obtener su precio
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. Detener la sesión
app.stop_interaction(scrape_id)
```
```js
import { Firecrawl } from 'firecrawl';
const app = new Firecrawl({
// No se necesita API key para comenzar — agrega una para límites de tasa más altos:
// apiKey: 'fc-YOUR-API-KEY',
});
// 1. Extraer la página principal de Amazon
const result = await app.scrape('https://www.amazon.com', { formats: ['markdown'] });
const scrapeId = result.metadata?.scrapeId;
// 2. Interactuar — buscar un producto y obtener su precio
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. Detener la sesión
await app.stopInteraction(scrapeId);
```
```bash
# 1. Extraer la página principal de Amazon
# No se necesita API key para comenzar — añade -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
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. Interactuar — buscar un producto y obtener su precio
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. Detener la sesión
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
```
```bash
# 1. Scrape la página principal de Amazon (el ID de scrape se guarda automáticamente)
firecrawl scrape https://www.amazon.com
# 2. Interactúa — busca un producto y obtén su precio
firecrawl interact "Search for iPhone 16 Pro Max"
firecrawl interact "Click on the first result and tell me the price"
# 3. Detén la sesión
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
}
```
## Interactúa mediante prompts [#interactúa-mediante-prompts]
La forma más simple de interactuar con una página. Describe lo que quieres en lenguaje natural y hará clic, escribirá, se desplazará y extraerá datos automáticamente.
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
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
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 respuesta incluye un campo `output` con la respuesta del agente:
```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
}
```
### Mantén los prompts pequeños y enfocados [#mantén-los-prompts-pequeños-y-enfocados]
Los prompts funcionan mejor cuando cada uno consiste en una **única tarea clara**. En lugar de pedirle al agente que realice un flujo de trabajo complejo de varios pasos de una sola vez, divídelo en llamadas `interact` independientes. Cada llamada reutiliza la misma sesión del navegador, por lo que el estado se conserva entre una y otra.
## Ejecución de código [#ejecución-de-código]
Para tener control total, puedes ejecutar código directamente en el sandbox del navegador. La variable `page` (un objeto Page de Playwright) está disponible en Node.js y Python. El modo Bash incluye [agent-browser](https://github.com/vercel-labs/agent-browser) preinstalado. También puedes hacer capturas de pantalla dentro de la sesión: usa `(await page.screenshot()).toString("base64")` en Node.js, `await page.screenshot(path="/tmp/screenshot.png")` en Python o `agent-browser screenshot` en Bash.
### Node.js (Playwright) [#nodejs-playwright]
El lenguaje predeterminado. Escribe código de Playwright directamente. `page` ya está conectado al navegador.
Python
Node
cURL
CLI
```python
response = app.interact(scrape_id, code="""
// Hacer clic en un botón y esperar la navegación
await page.click('#next-page');
await page.waitForLoadState('networkidle');
// Extraer contenido de la nueva página
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: `
// Hacer clic en un botón y esperar la navegación
await page.click('#next-page');
await page.waitForLoadState('networkidle');
// Extraer contenido de la nueva página
const title = await page.title();
const content = await page.$eval('.article-body', el => el.textContent);
JSON.stringify({ title, content });
`,
});
console.log(response.result);
```
```bash
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
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
# Usa el último scrape automáticamente
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 });
"
# O pasa un ID de scrape explícitamente
# firecrawl interact -c "await page.title()"
```
### Python [#python]
Configura `language` como `"python"` para usar la API de 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
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para obtener límites de tasa más altos:
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) es una CLI preinstalada en el sandbox con más de 60 comandos. Proporciona un árbol de accesibilidad con referencias de elementos (`@e1`, `@e2`, ...), lo que es ideal para la automatización controlada por LLM.
Python
Node
cURL
CLI
```python
# Tomar una instantánea para ver los elementos interactivos
snapshot = app.interact(
scrape_id,
code="agent-browser snapshot -i",
language="bash",
)
print(snapshot.stdout)
# Salida:
# [document]
# @e1 [input type="text"] "Search..."
# @e2 [button] "Search"
# @e3 [link] "About"
# Interactuar con elementos usando @refs
app.interact(
scrape_id,
code='agent-browser fill @e1 "firecrawl" && agent-browser click @e2',
language="bash",
)
```
```js
// Tomar una instantánea para ver los elementos interactivos
const snapshot = await app.interact(scrapeId, {
code: 'agent-browser snapshot -i',
language: 'bash',
});
console.log(snapshot.stdout);
// Salida:
// [document]
// @e1 [input type="text"] "Search..."
// @e2 [button] "Search"
// @e3 [link] "About"
// Interactuar con elementos usando @refs
await app.interact(scrapeId, {
code: 'agent-browser fill @e1 "firecrawl" && agent-browser click @e2',
language: 'bash',
});
```
```bash
# Tomar una instantánea para ver los elementos interactivos
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para mayores límites de tasa:
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"}'
# Interactuar con los elementos utilizando @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
# Tomar una instantánea para ver los elementos interactivos
firecrawl interact --bash -c "agent-browser snapshot -i"
# Interactuar con elementos utilizando @refs
firecrawl interact --bash -c 'agent-browser fill @e1 "firecrawl" && agent-browser click @e2'
```
Comandos comunes de agent-browser:
| Comando | Descripción |
| ------------------------- | ------------------------------------------------------------ |
| `snapshot` | Árbol de accesibilidad completo con referencias de elementos |
| `snapshot -i` | Solo elementos interactivos |
| `click @e1` | Hacer clic en un elemento por referencia |
| `fill @e1 "text"` | Borrar el campo y escribir texto |
| `type @e1 "text"` | Escribir sin borrar |
| `press Enter` | Pulsar una tecla del teclado |
| `scroll down 500` | Desplazarse 500 píxeles hacia abajo |
| `get text @e1` | Obtener el contenido de texto |
| `get url` | Obtener la URL actual |
| `wait @e1` | Esperar a que aparezca el elemento |
| `wait --load networkidle` | Esperar a que la red quede inactiva |
| `find text "X" click` | Buscar un elemento por texto y hacer clic |
| `screenshot` | Tomar una captura de pantalla de la página actual |
| `eval "js code"` | Ejecutar JavaScript en la página |
## vista en vivo [#vista-en-vivo]
Cada respuesta de interact devuelve una `liveViewUrl` que puedes incrustar para ver el navegador en tiempo real. Es útil para depuración, demos o para crear interfaces con navegador.
```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
```
### Vista en vivo interactiva [#vista-en-vivo-interactiva]
La respuesta también incluye un `interactiveLiveViewUrl`. A diferencia de la vista en vivo estándar, que es solo de visualización, la vista en vivo interactiva permite a los usuarios hacer clic, escribir e interactuar con la sesión del navegador directamente a través del stream integrado. Esto resulta útil para crear interfaces de navegador orientadas al usuario, como flujos de inicio de sesión o flujos de trabajo guiados en los que los usuarios finales necesitan controlar el navegador.
```html
```
### URL de CDP [#url-de-cdp]
Cada respuesta de interact también devuelve una `cdpUrl`: la URL de WebSocket sin procesar del Chrome DevTools Protocol (CDP) para la sesión del navegador. Úsala para conectarte directamente a la sesión activa desde Playwright, Puppeteer o cualquier cliente CDP, y controlar el navegador con tu propio código.
```js
import { chromium } from "playwright";
const browser = await chromium.connectOverCDP(cdpUrl);
const context = browser.contexts()[0];
const page = context.pages()[0];
```
## Ciclo de vida de la sesión [#ciclo-de-vida-de-la-sesión]
### Creación [#creación]
La primera llamada `POST /v2/scrape/{scrapeId}/interact` continúa la sesión de scraping e inicia la interacción.
### Reutilización [#reutilización]
Las llamadas posteriores a `interact` sobre el mismo `scrapeId` reutilizan la sesión existente. El navegador permanece abierto y conserva su estado entre llamadas, por lo que puedes encadenar varias interacciones:
Python
Node
CLI
```python
# Primera llamada: haz clic en una pestaña
app.interact(scrape_id, code="await page.click('#tab-2')")
# Segunda llamada: la pestaña sigue seleccionada, extrae su contenido
result = app.interact(scrape_id, code="await page.$eval('#tab-2-content', el => el.textContent)")
print(result.result)
```
```js
// Primera llamada: haz clic en una pestaña
await app.interact(scrapeId, { code: "await page.click('#tab-2')" });
// Segunda llamada: la pestaña sigue seleccionada, extrae su contenido
const result = await app.interact(scrapeId, {
code: "await page.$eval('#tab-2-content', el => el.textContent)",
});
console.log(result.result);
```
```bash
# Primera llamada: haz clic en una pestaña
firecrawl interact -c "await page.click('#tab-2')"
# Segunda llamada: la pestaña sigue seleccionada, extrae su contenido
firecrawl interact -c "await page.\$eval('#tab-2-content', el => el.textContent)"
```
### Limpieza [#limpieza]
Detén la sesión explícitamente al terminar:
Python
Node
cURL
CLI
```python
app.stop_interaction(scrape_id)
```
```js
await app.stopInteraction(scrapeId);
```
```bash
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
```
```bash
# Detiene la última sesión de scrape
firecrawl interact stop
# O detener una sesión específica por ID
# firecrawl interact stop
```
Las sesiones también expiran automáticamente según el TTL (predeterminado: 10 minutos) o el timeout de inactividad (predeterminado: 5 minutos).
Detén siempre las sesiones al terminar para evitar Billing innecesario. Los credits se prorratean por segundo.
## Perfiles persistentes con Scraping + Interact [#perfiles-persistentes-con-scraping--interact]
De forma predeterminada, cada sesión de scraping + interact se inicia con un navegador limpio. Con `profile`, puedes guardar y reutilizar el estado del navegador (cookies, localStorage, sesiones) entre scrapings. Esto resulta útil para mantener la sesión iniciada y conservar las preferencias.
Pasa el objeto `profile` en la solicitud inicial `POST /v2/scrape`. No pases `profile` a `POST /v2/scrape/{scrapeId}/interact`; la sesión de interact reutiliza la sesión del navegador y la configuración del perfil del trabajo de scraping. Detén la sesión de interact con `DELETE /v2/scrape/{scrapeId}/interact` para que puedan guardarse los cambios del perfil.
```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"
```
El ciclo de vida del perfil es:
1. Crea el scraping con `profile.name` y `saveChanges: true`.
2. Ejecuta interacciones con prompt o código usando el `scrapeId` devuelto.
3. Detén la sesión para guardar cookies, localStorage y otro estado del navegador.
4. Inicia un scraping posterior con el mismo `profile.name`. Usa `saveChanges: false` cuando solo quieras leer el estado existente sin volver a escribir cambios.
Python
Node
cURL
CLI
```python
from firecrawl import Firecrawl
app = Firecrawl(
# No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
# api_key="fc-YOUR-API-KEY",
)
# Sesión 1: Scrape con un perfil, inicia sesión y luego detén (el estado se guarda)
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)
# Sesión 2: Scrape con el mismo perfil en modo de solo lectura — ya con sesión iniciada
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({
// No se necesita API key para comenzar — agrega una para obtener límites de tasa más altos:
// apiKey: 'fc-YOUR-API-KEY',
});
// Sesión 1: Scrape con un perfil, inicia sesión y luego detén (el estado se guarda)
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);
// Sesión 2: Scrape con el mismo perfil en modo de solo lectura — ya con sesión iniciada
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
# No se necesita API key para comenzar — agrega -H "Authorization: Bearer $FIRECRAWL_API_KEY" para límites de tasa más altos:
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"}'
# Detener - el estado se guarda en el perfil
curl -s -X DELETE "https://api.firecrawl.dev/v2/scrape/$SCRAPE_ID/interact"
# Sesión 2: Scrape nuevamente con el mismo perfil en modo de solo lectura - ya con sesión iniciada
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
# Sesión 1: Scrape con un perfil, inicia sesión y luego detén (el estado se guarda)
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
# Sesión 2: Scrape con el mismo perfil — ya has iniciado sesión
firecrawl scrape https://app.example.com/dashboard --profile my-app
firecrawl interact "Extract the dashboard data"
firecrawl interact stop
# Solo lectura: carga el estado del perfil sin guardar los cambios
firecrawl scrape https://app.example.com/dashboard --profile my-app --no-save-changes
```
| Parámetro | Predeterminado | Descripción |
| ------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` | None | Nombre del perfil persistente. Los scrapings con el mismo nombre comparten el estado del navegador. |
| `saveChanges` | `true` | Cuando es `true`, el estado del navegador se vuelve a guardar en el perfil cuando se detiene la sesión de interact. Establécelo en `false` para cargar datos existentes sin escribir cambios, lo que resulta útil cuando necesitas varios lectores concurrentes. |
Solo una sesión puede guardar en un perfil a la vez. Si otra sesión ya está guardando, recibirás un error `409`. Aun así, puedes abrir el mismo perfil con `saveChanges: false` o volver a intentarlo más tarde.
El estado del navegador se guarda cuando se detiene la sesión de interact. Detén siempre la sesión cuando termines para que el perfil pueda reutilizarse.
### Validar la persistencia [#validar-la-persistencia]
Puedes probar la persistencia sin depender de un flujo de inicio de sesión real: escribe un valor en `localStorage` en una sesión, detenla y luego lee ese valor en una segunda sesión con el mismo perfil.
```bash title="cURL"
# Sesión 1: escribir el estado del navegador y guardarlo
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"
# Sesión 2: cargar el mismo perfil en modo de solo lectura y verificar el valor
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 segunda respuesta de Interact debería mostrar `localStorage` como `"saved"` y `cookie` como `true`.
Puede que los perfiles creados a través de la API todavía no aparezcan en Dashboard > Interact > Profiles. Actualmente, el dashboard no ofrece un inventario completo de los perfiles persistentes creados mediante la API.
## Cuándo usar cada opción [#cuándo-usar-cada-opción]
| Caso de uso | Recomendado | Por qué |
| -------------------------------------------- | ------------------------------- | --------------------------------------------- |
| Búsqueda web | [Search](/es/features/search) | Endpoint de búsqueda específico |
| Obtener contenido limpio de una URL | [scraping](/es/features/scrape) | Una llamada a la API, sin necesidad de sesión |
| Hacer clic, escribir y navegar en una página | **Interact** (prompt) | Solo descríbelo en inglés |
| Extraer datos tras interacciones | **Interact** (prompt) | No se necesitan selectores |
| Lógica de scraping compleja | **Interact** (code) | Control total de Playwright |
**Interact vs Browser Sandbox**: Interact se basa en la misma infraestructura que [Browser Sandbox](/es/features/browser), pero ofrece una mejor interfaz para el patrón más común: hacer scraping de una página y luego profundizar. Browser Sandbox es mejor cuando necesitas una sesión del navegador independiente que no esté vinculada a un scraping específico.
## Precios [#precios]
* **Solo código** (sin `prompt`): 2 credits por minuto de sesión
* **Con prompts de IA**: 7 credits por minuto de sesión
* **scraping**: se factura por separado (1 credit por scraping, más cualquier costo específico del formato)
## Referencia de la API [#referencia-de-la-api]
* [Ejecutar Interact](/es/api-reference/endpoint/scrape-execute): `POST /v2/scrape/{scrapeId}/interact`
* [Detener Interact](/es/api-reference/endpoint/scrape-browser-delete): `DELETE /v2/scrape/{scrapeId}/interact`
### Cuerpo de la solicitud (POST) [#cuerpo-de-la-solicitud-post]
| Campo | Tipo | Predeterminado | Descripción |
| ---------- | -------- | -------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `prompt` | `string` | Ninguno | Tarea en lenguaje natural para el agente de IA. Obligatorio si no se establece `code`. Máximo 10.000 caracteres. |
| `code` | `string` | Ninguno | Código que se va a ejecutar (Node.js, Python o Bash). Obligatorio si no se establece `prompt`. Máximo 100.000 caracteres. |
| `language` | `string` | `"node"` | `"node"`, `"python"` o `"bash"`. Solo se usa con `code`. |
| `timeout` | `number` | `30` | Timeout en segundos (1–300). |
| `origin` | `string` | Ninguno | Identificador del llamante para el seguimiento de la actividad. |
### Respuesta [#respuesta]
| Field | Description |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `success` | `true` si la ejecución se completó sin errores |
| `cdpUrl` | URL WebSocket sin procesar de Chrome DevTools Protocol (CDP) para la sesión del navegador. Conéctate directamente con Playwright, Puppeteer o cualquier cliente CDP |
| `liveViewUrl` | URL de vista en vivo de solo lectura para la sesión del navegador |
| `interactiveLiveViewUrl` | URL de vista en vivo interactiva (quienes la vean pueden controlar el navegador) |
| `output` | La respuesta en lenguaje natural del agente a tu prompt. Solo está presente cuando se utiliza `prompt`. |
| `stdout` | Salida estándar de la ejecución del código |
| `result` | Valor de retorno sin procesar del sandbox. Para `code`: la última expresión evaluada. Para `prompt`: la captura sin procesar de la página que el agente utilizó para producir `output`. |
| `stderr` | Salida de error estándar |
| `exitCode` | Código de salida (`0` = éxito) |
| `killed` | `true` si la ejecución se finalizó debido a timeout |
***
¿Tienes comentarios o necesitas ayuda? Envía un correo a [help@firecrawl.com](mailto:help@firecrawl.com) o comunícate en [Discord](https://discord.gg/firecrawl).