> ## 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.
# Raspar
> Transforme qualquer URL em dados limpos
Firecrawl converte páginas da web em Markdown, ideal para aplicações com LLMs.
* Gerencia complexidades: proxies, cache, limites de taxa, conteúdo bloqueado por JS
* Lida com conteúdo dinâmico: sites dinâmicos, sites renderizados em JS, PDFs, imagens
* Gera Markdown limpo, dados estruturados, capturas de tela ou HTML.
Para mais detalhes, consulte a [Referência da API do endpoint Scrape](https://docs.firecrawl.dev/api-reference/endpoint/scrape).
Teste scraping no playground interativo — sem precisar de código.
## Extraindo dados de uma URL com o Firecrawl
### endpoint /scrape
Usado para extrair o conteúdo de uma URL.
### Instalação
```python Python theme={null}
# pip install firecrawl-py
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY")
```
```js Node.js theme={null}
# npm install @mendable/firecrawl-js
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-SUA-CHAVE-API" });
```
```bash CLI theme={null}
# Instale globalmente com npm
npm install -g firecrawl
# Autentique (configuração única)
firecrawl login
```
### Uso
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY")
# Raspar um site:
doc = firecrawl.scrape("https://firecrawl.dev", formats=["markdown", "html"])
print(doc)
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
// Fazer a raspagem de um site:
const doc = await firecrawl.scrape('https://firecrawl.dev', { formats: ['markdown', 'html'] });
console.log(doc);
```
```bash cURL theme={null}
curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://firecrawl.dev",
"formats": ["markdown", "html"]
}'
```
```bash CLI theme={null}
# Scrape a URL and get markdown
firecrawl https://firecrawl.dev
# Com múltiplos formatos (retorna JSON)
firecrawl https://firecrawl.dev --format markdown,html,links --pretty
```
Para mais detalhes sobre os parâmetros, consulte a [Referência da API](https://docs.firecrawl.dev/api-reference/endpoint/scrape).
Cada scrape consome 1 crédito. Créditos adicionais são cobrados para certas opções: modo JSON custa 4 créditos adicionais por página, proxy avançado custa 4 créditos adicionais por página e o processamento de PDFs custa 1 crédito por página de PDF.
### Resposta
Os SDKs retornarão o objeto de dados diretamente. O cURL retornará o payload exatamente como mostrado abaixo.
```json theme={null}
{
"success": true,
"data" : {
"markdown": "A Launch Week I chegou! [Confira nosso lançamento do Dia 2 🚀](https://www.firecrawl.dev/blog/launch-week-i-day-2-doubled-rate-limits)[💥 Ganhe 2 meses grátis...",
"html": "
## Formatos de Scrape
Agora você pode escolher em quais formatos deseja o seu resultado. Você pode especificar vários formatos de saída. Os formatos suportados são:
* Markdown (`markdown`)
* Resumo (`summary`)
* HTML (`html`) — versão limpa do HTML da página
* HTML bruto (`rawHtml`) — HTML não modificado conforme recebido da página
* Captura de tela (`screenshot`, com opções como `fullPage`, `quality`, `viewport`)
* Links (`links`)
* JSON (`json`) — saída estruturada
* Imagens (`images`) — extrair todas as URLs de imagens da página
* Branding (`branding`) — extrair identidade de marca e sistema de design
As chaves de saída corresponderão ao formato que você escolher.
### endpoint /scrape (com json)
Usado para extrair dados estruturados de páginas extraídas.
```python Python theme={null}
from firecrawl import Firecrawl
from pydantic import BaseModel
app = Firecrawl(api_key="fc-SUA-CHAVE-API")
class CompanyInfo(BaseModel):
company_mission: str
supports_sso: bool
is_open_source: bool
is_in_yc: bool
result = app.scrape(
'https://firecrawl.dev',
formats=[{
"type": "json",
"schema": CompanyInfo.model_json_schema()
}],
only_main_content=False,
timeout=120000
)
print(result)
```
```js Node theme={null}
import Firecrawl from "@mendable/firecrawl-js";
import { z } from "zod";
const app = new Firecrawl({
apiKey: "fc-YOUR_API_KEY"
});
// Define o schema para extrair os conteúdos
const schema = z.object({
company_mission: z.string(),
supports_sso: z.boolean(),
is_open_source: z.boolean(),
is_in_yc: z.boolean()
});
const result = await app.scrape("https://firecrawl.dev", {
formats: [{
type: "json",
schema: schema
}],
});
console.log(result);
```
```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/scrape \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"url": "https://firecrawl.dev",
"formats": [ {
"type": "json",
"schema": {
"type": "object",
"properties": {
"company_mission": {
"type": "string"
},
"supports_sso": {
"type": "boolean"
},
"is_open_source": {
"type": "boolean"
},
"is_in_yc": {
"type": "boolean"
}
},
"required": [
"company_mission",
"supports_sso",
"is_open_source",
"is_in_yc"
]
}
} ]
}'
```
Resultado:
```json JSON theme={null}
{
"success": true,
"data": {
"json": {
"company_mission": "Rastreamento e extração de dados na web com IA",
"supports_sso": true,
"is_open_source": true,
"is_in_yc": true
},
"metadata": {
"title": "Firecrawl",
"description": "Rastreamento e extração de dados na web com IA",
"robots": "follow, index",
"ogTitle": "Firecrawl",
"ogDescription": "Rastreamento e extração de dados na web com IA",
"ogUrl": "https://firecrawl.dev/",
"ogImage": "https://firecrawl.dev/og.png",
"ogLocaleAlternate": [],
"ogSiteName": "Firecrawl"
"sourceURL": "https://firecrawl.dev/"
},
}
}
```
Agora é possível extrair sem um esquema, bastando enviar um `prompt` para o endpoint. O LLM escolhe a estrutura dos dados.
```python Python theme={null}
from firecrawl import Firecrawl
app = Firecrawl(api_key="fc-YOUR-API-KEY")
result = app.scrape(
'https://firecrawl.dev',
formats=[{
"type": "json",
"prompt": "Extraia a missão da empresa presente na página."
}],
only_main_content=False,
timeout=120000
)
print(result)
```
```js Node theme={null}
import Firecrawl from "@mendable/firecrawl-js";
const app = new Firecrawl({
apiKey: "fc-SUA_CHAVE_DE_API"
});
const result = await app.scrape("https://firecrawl.dev", {
formats: [{
type: "json",
prompt: "Extraia a missão da empresa desta página."
}]
});
console.log(result);
```
```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/scrape \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"url": "https://firecrawl.dev",
"formats": [{
"type": "json",
"prompt": "Extraia a missão da empresa desta página."
}]
}'
```
Resultado:
```json JSON theme={null}
{
"success": true,
"data": {
"json": {
"company_mission": "Raspagem e extração de dados na web com IA",
},
"metadata": {
"title": "Firecrawl",
"description": "Raspagem e extração de dados na web com IA",
"robots": "seguir, indexar",
"ogTitle": "Firecrawl",
"ogDescription": "Raspagem e extração de dados na web com IA",
"ogUrl": "https://firecrawl.dev/",
"ogImage": "https://firecrawl.dev/og.png",
"ogLocaleAlternate": [],
"ogSiteName": "Firecrawl",
"sourceURL": "https://firecrawl.dev/"
},
}
}
```
### Opções do formato JSON
Ao usar o formato `json`, passe um objeto dentro de `formats` com os seguintes parâmetros:
* `schema`: JSON Schema para a saída estruturada.
* `prompt`: Prompt opcional para orientar a extração quando houver um schema ou quando você preferir uma orientação leve.
## Extrair identidade de marca
### endpoint /scrape (com branding)
O formato de branding extrai informações completas sobre a identidade de marca de uma página da web, incluindo cores, fontes, tipografia, espaçamento, componentes de UI e mais. Isso é útil para análise de design systems, monitoramento de marca ou para criar ferramentas que precisam compreender a identidade visual de um site.
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')
result = firecrawl.scrape(
url='https://firecrawl.dev',
formats=['branding']
)
print(result['branding'])
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
const result = await firecrawl.scrape('https://firecrawl.dev', {
formats: ['branding']
});
console.log(result.branding);
```
```bash cURL theme={null}
curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://firecrawl.dev",
"formatos": ["branding"]
}'
```
### Resposta
O formato de branding retorna um objeto `BrandingProfile` completo com a seguinte estrutura:
```json Output theme={null}
{
"success": true,
"data": {
"branding": {
"colorScheme": "dark",
"logo": "https://firecrawl.dev/logo.svg",
"colors": {
"primary": "#FF6B35",
"secondary": "#004E89",
"accent": "#F77F00",
"background": "#1A1A1A",
"textPrimary": "#FFFFFF",
"textSecondary": "#B0B0B0"
},
"fonts": [
{
"family": "Inter"
},
{
"family": "Roboto Mono"
}
],
"typography": {
"fontFamilies": {
"primary": "Inter",
"heading": "Inter",
"code": "Roboto Mono"
},
"fontSizes": {
"h1": "48px",
"h2": "36px",
"h3": "24px",
"body": "16px"
},
"fontWeights": {
"regular": 400,
"medium": 500,
"bold": 700
}
},
"spacing": {
"baseUnit": 8,
"borderRadius": "8px"
},
"components": {
"buttonPrimary": {
"background": "#FF6B35",
"textColor": "#FFFFFF",
"borderRadius": "8px"
},
"buttonSecondary": {
"background": "transparent",
"textColor": "#FF6B35",
"borderColor": "#FF6B35",
"borderRadius": "8px"
}
},
"images": {
"logo": "https://firecrawl.dev/logo.svg",
"favicon": "https://firecrawl.dev/favicon.ico",
"ogImage": "https://firecrawl.dev/og-image.png"
}
}
}
}
```
### Estrutura do Perfil de Branding
O objeto `branding` contém as seguintes propriedades:
* `colorScheme`: Esquema de cores detectado (`"light"` ou `"dark"`)
* `logo`: URL do logotipo principal
* `colors`: Objeto com as cores da marca:
* `primary`, `secondary`, `accent`: Cores principais da marca
* `background`, `textPrimary`, `textSecondary`: Cores de UI
* `link`, `success`, `warning`, `error`: Cores semânticas
* `fonts`: Lista (array) de famílias tipográficas usadas na página
* `typography`: Informações detalhadas de tipografia:
* `fontFamilies`: Famílias tipográficas primária, de títulos e de código
* `fontSizes`: Definições de tamanho para títulos e corpo do texto
* `fontWeights`: Definições de espessura (leve, regular, média, negrito)
* `lineHeights`: Valores de altura de linha para diferentes tipos de texto
* `spacing`: Informações de espaçamento e layout:
* `baseUnit`: Unidade base de espaçamento em pixels
* `borderRadius`: Raio de borda padrão
* `padding`, `margins`: Valores de espaçamento
* `components`: Estilos de componentes de UI:
* `buttonPrimary`, `buttonSecondary`: Estilos de botões
* `input`: Estilos de campos de entrada
* `icons`: Informações de estilo de ícones
* `images`: Imagens da marca (logo, favicon, og:image)
* `animations`: Configurações de animação e transição
* `layout`: Configuração de layout (grid, alturas de cabeçalho/rodapé)
* `personality`: Traços de personalidade da marca (tom, energia, público-alvo)
### Combinando com outros formatos
Você pode combinar o formato de branding com outros formatos para obter dados completos da página:
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')
result = firecrawl.scrape(
url='https://firecrawl.dev',
formats=['markdown', 'branding', 'screenshot']
)
print(result['markdown'])
print(result['branding'])
print(result['screenshot'])
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-SUA-CHAVE-DE-API" });
const result = await firecrawl.scrape('https://firecrawl.dev', {
formats: ['markdown', 'branding', 'screenshot']
});
console.log(result.markdown);
console.log(result.branding);
console.log(result.screenshot);
```
```bash cURL theme={null}
curl -s -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://firecrawl.dev",
"formatos": ["markdown", "branding", "screenshot"]
}'
```
## Interagindo com a página com ações
O Firecrawl permite executar várias ações em uma página da web antes de fazer o scraping do conteúdo. Isso é especialmente útil para interagir com conteúdo dinâmico, navegar entre páginas ou acessar conteúdo que exige interação do usuário.
Veja um exemplo de como usar ações para acessar google.com, pesquisar por Firecrawl, clicar no primeiro resultado e fazer uma captura de tela.
É importante, quase sempre, usar a ação `wait` antes/depois de executar outras ações para dar tempo suficiente para a página carregar.
### Exemplo
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY")
doc = firecrawl.scrape(
url="https://example.com/login",
formats=["markdown"],
actions=[
{"type": "write", "text": "john@example.com"},
{"type": "press", "key": "Tab"},
{"type": "write", "text": "secret"},
{"type": "click", "selector": 'button[type="submit"]'},
{"type": "wait", "milliseconds": 1500},
{"type": "screenshot", "full_page": True},
],
)
print(doc.markdown, doc.screenshot)
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-SUA-CHAVE-DE-API" });
const doc = await firecrawl.scrape('https://example.com/login', {
formatos: ['markdown'],
ações: [
{ type: 'write', text: 'john@example.com' },
{ type: 'press', key: 'Tab' },
{ type: 'write', text: 'secret' },
{ type: 'click', selector: 'button[type="submit"]' },
{ type: 'wait', milliseconds: 1500 },
{ type: 'screenshot', fullPage: true },
],
});
console.log(doc.markdown, doc.screenshot);
```
```bash cURL theme={null}
curl -X POST https://api.firecrawl.dev/v2/scrape \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_API_KEY' \
-d '{
"url": "https://example.com/login",
"formats": ["markdown"],
"actions": [
{ "type": "write", "text": "john@example.com" },
{ "type": "press", "key": "Tab" },
{ "type": "write", "text": "secret" },
{ "type": "click", "selector": "button[type=\"submit\"]" },
{ "type": "wait", "milliseconds": 1500 },
{ "type": "screenshot", "fullPage": true },
],
}'
```
### Saída
```json JSON theme={null}
{
"success": true,
"data": {
"markdown": "Nossa primeira Launch Week chegou ao fim! [Confira o recap 🚀](blog/firecrawl-launch-week-1-recap)...",
"actions": {
"screenshots": [
"https://alttmdsdujxrfnakrkyi.supabase.co/storage/v1/object/public/media/screenshot-75ef2d87-31e0-4349-a478-fb432a29e241.png"
],
"scrapes": [
{
"url": "https://www.firecrawl.dev/",
"html": "Firecrawl
"
}
]
},
"metadata": {
"title": "Home - Firecrawl",
"description": "O Firecrawl rastreia e converte qualquer site em Markdown limpo.",
"language": "en",
"keywords": "Firecrawl,Markdown,Dados,Mendable,LangChain",
"robots": "index, follow",
"ogTitle": "Firecrawl",
"ogDescription": "Transforme qualquer site em dados prontos para LLMs.",
"ogUrl": "https://www.firecrawl.dev/",
"ogImage": "https://www.firecrawl.dev/og.png?123",
"ogLocaleAlternate": [],
"ogSiteName": "Firecrawl"
"sourceURL": "http://google.com",
"statusCode": 200
}
}
}
```
Para mais detalhes sobre os parâmetros de ações, consulte a [referência da API](https://docs.firecrawl.dev/api-reference/endpoint/scrape).
## Localização e idioma
Especifique o país e os idiomas preferidos para obter conteúdo relevante com base no seu local de destino e nas suas preferências de idioma.
### Como funciona
Quando você define as configurações de localização, o Firecrawl usará um proxy apropriado, se disponível, e emulará as configurações correspondentes de idioma e fuso horário. Por padrão, a localização é definida como “US” se não for especificada.
### Uso
Para usar as configurações de localização e idioma, inclua o objeto `location` no corpo da sua requisição com as seguintes propriedades:
* `country`: Código de país ISO 3166-1 alpha-2 (por exemplo, 'US', 'AU', 'DE', 'JP'). O padrão é 'US'.
* `languages`: Uma lista (array) de idiomas e localidades preferidos para a requisição, em ordem de prioridade. O padrão é o idioma da localização especificada.
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key="fc-YOUR-API-KEY")
doc = firecrawl.scrape('https://example.com',
formats=['markdown'],
location={
'country': 'US',
'languages': ['en']
}
)
print(doc)
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
const doc = await firecrawl.scrape('https://example.com', {
formatos: ['markdown'],
localização: { país: 'US', idiomas: ['en'] },
});
console.log(doc.metadata);
```
```bash cURL theme={null}
curl -X POST "https://api.firecrawl.dev/v2/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com",
"formatos": ["markdown"],
"location": { "country": "US", "languages": ["en"] }
}'
```
Para mais detalhes sobre as localizações compatíveis, consulte a [documentação de proxies](/pt-BR/features/proxies).
## Cache e maxAge
Para acelerar as requisições, o Firecrawl retorna resultados do cache por padrão quando há uma cópia recente disponível.
* **Janela de frescor padrão**: `maxAge = 172800000` ms (2 dias). Se a página em cache for mais recente do que isso, ela é retornada instantaneamente; caso contrário, a página é coletada novamente e então armazenada em cache.
* **Desempenho**: Pode acelerar as coletas em até 5x quando os dados não precisam estar ultra recentes.
* **Sempre buscar conteúdo novo**: Defina `maxAge` como `0`. Observe que isso ignora totalmente o cache, então toda requisição passa por todo o pipeline de coleta, o que significa que a requisição levará mais tempo para ser concluída e terá maior chance de falhar. Use um `maxAge` diferente de zero se a atualização em toda requisição não for crítica.
* **Evitar armazenamento**: Defina `storeInCache` como `false` se você não quiser que o Firecrawl armazene em cache os resultados desta requisição.
* **Rastreio de mudanças**: Requisições que incluem `changeTracking` ignoram o cache, então `maxAge` é desconsiderado.
Exemplo (forçar conteúdo novo):
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')
doc = firecrawl.scrape(url='https://example.com', max_age=0, formats=['markdown'])
print(doc)
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
const doc = await firecrawl.scrape('https://example.com', { maxAge: 0, formats: ['markdown'] });
console.log(doc);
```
```bash cURL theme={null}
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",
"maxAge": 0,
"formats": ["markdown"]
}'
```
Exemplo (usar uma janela de cache de 10 minutos):
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key='fc-YOUR_API_KEY')
doc = firecrawl.scrape(url='https://example.com', max_age=600000, formats=['markdown', 'html'])
print(doc)
```
```js Node theme={null}
const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });
const doc = await firecrawl.scrape('https://example.com', { maxAge: 600000, formats: ['markdown', 'html'] });
console.log(doc);
```
```bash cURL theme={null}
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",
"maxAge": 600000,
"formats": ["markdown", "html"]
}'
```
## Scraping em lote de várias URLs
Agora é possível fazer scraping em lote de várias URLs ao mesmo tempo. A função recebe as URLs iniciais e parâmetros opcionais como argumentos. O parâmetro params permite definir opções adicionais para a tarefa de scraping em lote, como os formatos de saída.
### Como funciona
Funciona de forma muito semelhante ao endpoint `/crawl`. Ele cria um job de raspagem em lote e retorna um ID do job para você acompanhar o status da raspagem em lote.
O SDK oferece 2 métodos: síncrono e assíncrono. O método síncrono retorna os resultados do job de raspagem em lote, enquanto o método assíncrono retorna um ID do job que você pode usar para verificar o status da raspagem em lote.
### Como usar
```python Python theme={null}
from firecrawl import Firecrawl
firecrawl = Firecrawl(api_key="fc-SUA-API-KEY")
job = firecrawl.batch_scrape([
"https://firecrawl.dev",
"https://docs.firecrawl.dev",
], formats=["markdown"], poll_interval=2, wait_timeout=120)
print(job)
```
```js Node theme={null}
import Firecrawl from '@mendable/firecrawl-js';
const firecrawl = new Firecrawl({ apiKey: "fc-SUA-API-KEY" });
const job = await firecrawl.batchScrape([
'https://firecrawl.dev',
'https://docs.firecrawl.dev',
], { options: { formats: ['markdown'] }, pollInterval: 2, timeout: 120 });
console.log(job);
```
```bash cURL theme={null}
curl -s -X POST "https://api.firecrawl.dev/v2/batch/scrape" \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"urls": ["https://firecrawl.dev", "https://docs.firecrawl.dev"],
"formats": ["markdown"]
}'
```
### Resposta
Se você estiver usando os métodos síncronos dos SDKs, eles retornarão os resultados do job de scraping em lote. Caso contrário, será retornado um ID de job que você pode usar para verificar o status do scraping em lote.
#### Sincronamente
```json Concluído theme={null}
{
"status": "completed",
"total": 36,
"completed": 36,
"creditsUsed": 36,
"expiresAt": "2024-00-00T00:00:00.000Z",
"next": "https://api.firecrawl.dev/v2/batch/scrape/123-456-789?skip=26",
"data": [
{
"markdown": "[Página inicial da documentação do Firecrawl!...",
"html": "...",
"metadata": {
"title": "Crie um ‘chat com o site’ usando Groq Llama 3 | Firecrawl",
"language": "en",
"sourceURL": "https://docs.firecrawl.dev/learn/rag-llama3",
"description": "Aprenda a usar o Firecrawl, o Groq Llama 3 e o LangChain para criar um bot de ‘chat com o seu site’."
"ogLocaleAlternate": [],
"statusCode": 200
}
},
...
]
}
```
#### Assíncrono
Você pode usar o ID da tarefa para verificar o status do batch scrape chamando o endpoint `/batch/scrape/{id}`. Este endpoint deve ser usado enquanto a tarefa ainda estiver em execução ou logo após sua conclusão, **pois as tarefas de batch scrape expiram após 24 horas**.
```json theme={null}
{
"success": true,
"id": "123-456-789",
"url": "https://api.firecrawl.dev/v2/batch/scrape/123-456-789"
}
```
## Modo Enhanced
Para sites complexos, o Firecrawl oferece um modo enhanced que aumenta as taxas de sucesso ao mesmo tempo em que preserva a privacidade.
Saiba mais sobre o [Modo Enhanced](/pt-BR/features/enhanced-mode).