Rastreio de mudanças O rastreio de mudanças permite monitorar e detectar alterações em conteúdo na web ao longo do tempo. Este recurso está disponível nos SDKs de JavaScript e Python.

​
Visão geral

O rastreio de mudanças permite que você:
  • Detecte se uma página da web mudou desde a última coleta
  • Veja as mudanças específicas entre coletas
  • Obtenha dados estruturados sobre o que mudou
  • Controle a visibilidade das mudanças
Usando o formato changeTracking, você pode monitorar mudanças em um site e receber informações sobre:
  • previousScrapeAt: O carimbo de data/hora da coleta anterior com a qual a página atual está sendo comparada (null se não houve coleta anterior)
  • changeStatus: O resultado da comparação entre as duas versões da página
    • new: Esta página não existia ou não havia sido descoberta antes (geralmente tem previousScrapeAt null)
    • same: O conteúdo desta página não mudou desde a última coleta
    • changed: O conteúdo desta página mudou desde a última coleta
    • removed: Esta página foi removida desde a última coleta
  • visibility: A visibilidade da página/URL atual
    • visible: Esta página está visível, o que significa que sua URL foi descoberta por uma rota orgânica (por meio de links em outras páginas visíveis ou pelo sitemap)
    • hidden: Esta página não está visível, o que significa que ainda está disponível na web, mas não é mais encontrável via sitemap ou rastreamento do site. Só podemos identificar links invisíveis se eles tiverem sido visíveis — e capturados — durante uma coleta ou rastreamento anterior

​
SDKs

​
Uso básico

Para usar o rastreio de mudanças, inclua ‘changeTracking’ nos formatos ao fazer o scraping de uma URL: 
const firecrawl = new Firecrawl({ apiKey: 'your-api-key' });
const result = await firecrawl.scrape('https://example.com', {
  formats: ['markdown', 'changeTracking']
});

// Acesse os dados de rastreio de mudanças
console.log(result.changeTracking)
Exemplo de resposta: 
{
  "url": "https://firecrawl.dev",
  "markdown": "# Agentes de IA para experiências incríveis do cliente\n\nChatbots que encantam seus usuários...",
  "changeTracking": {
    "previousScrapeAt": "2025-04-10T12:00:00Z",
    "changeStatus": "alterado",
    "visibility": "visível"
  }
}

​
Opções avançadas

Você pode configurar o rastreio de mudanças passando um objeto no array formats: 
const result = await firecrawl.scrape('https://example.com', {
  formats: [
    'markdown',
    {
      type: 'changeTracking',
      modes: ['git-diff', 'json'], // Ativa modos específicos de rastreio de mudanças
      schema: {
        type: 'object',
        properties: {
          title: { type: 'string' },
          content: { type: 'string' }
        }
      }, // Esquema para comparação estruturada em JSON
      prompt: 'Prompt personalizado para extração', // Prompt personalizado opcional
      tag: 'production' // Tag opcional para históricos de rastreio de mudanças separados
    }
  ]
});

// Acessar alterações no formato git-diff
if (result.changeTracking.diff) {
  console.log(result.changeTracking.diff.text); // Texto de diff no estilo Git
  console.log(result.changeTracking.diff.json); // Dados de diff estruturados
}

// Acessar alterações na comparação em JSON
if (result.changeTracking.json) {
  console.log(result.changeTracking.json.title.previous); // Título anterior
  console.log(result.changeTracking.json.title.current); // Título atual
}

​
Exemplo de resultados do Git-Diff:

 **13 de abril de 2025**
 
-**17:55:05**
+**17:58:57**

...

​
Exemplo de resultados de comparação em JSON:

{
  "time": { 
    "previous": "2025-04-13T17:54:32Z", 
    "current": "2025-04-13T17:55:05Z" 
  }
}

​
Modelos de dados

O recurso de rastreio de mudanças inclui os seguintes modelos de dados: 
interface FirecrawlDocument {
  // ... other properties
  changeTracking?: {
    previousScrapeAt: string | null;
    changeStatus: "new" | "same" | "changed" | "removed";
    visibility: "visible" | "hidden";
    diff?: {
      text: string;
      json: {
        files: Array<{
          from: string | null;
          to: string | null;
          chunks: Array<{
            content: string;
            changes: Array<{
              type: string;
              normal?: boolean;
              ln?: number;
              ln1?: number;
              ln2?: number;
              content: string;
            }>;
          }>;
        }>;
      };
    };
    json?: any;
  };
}

interface ChangeTrackingFormat {
  type: 'changeTracking';
  prompt?: string;
  schema?: any;
  modes?: ("json" | "git-diff")[];
  tag?: string | null;
}

interface ScrapeParams {
  // ... other properties
  formats?: Array<'markdown' | 'html' | ChangeTrackingFormat>;
}

​
Modos de Rastreio de Mudanças

O recurso de rastreio de mudanças oferece suporte a dois modos:

​
Modo Git-Diff

O modo git-diff fornece um formato de diff tradicional, semelhante à saída do Git. Ele mostra alterações linha a linha, com adições e exclusões destacadas. Exemplo de saída: 
@@ -1,1 +1,1 @@
-conteúdo antigo
+novo conteúdo
A representação JSON estruturada do diff inclui:
  • files: Lista de arquivos alterados (no contexto da web, geralmente apenas um)
  • chunks: Seções de alterações dentro de um arquivo
  • changes: Alterações de linha individuais com tipo (add, delete, normal)

​
Modo JSON

O modo json oferece uma comparação estruturada de campos específicos extraídos do conteúdo. Isso é útil para acompanhar mudanças em pontos de dados específicos, em vez de em todo o conteúdo. Exemplo de saída: 
{
  "title": {
    "previous": "Título antigo",
    "current": "Título novo"
  },
  "price": {
    "previous": "US$ 19,99",
    "current": "US$ 24,99"
  }
}
Para usar o modo JSON, você precisa fornecer um esquema que defina os campos a extrair e comparar.

​
Fatos importantes

Aqui estão alguns detalhes importantes ao usar o recurso de rastreio de mudanças:
  • Método de comparação: As coletas (scrapes) são sempre comparadas com base na resposta em markdown.
    • O formato markdown também deve ser especificado ao usar o formato changeTracking. Outros formatos podem ser especificados adicionalmente.
    • O algoritmo de comparação é resistente a alterações em espaços em branco e na ordem do conteúdo. URLs de origem de iframes são ignoradas atualmente para aumentar a resiliência contra captchas e antibots com URLs aleatórias.
  • Correspondência com coletas anteriores: As coletas anteriores usadas para comparação são atualmente associadas pelo URL de origem, pelo ID da equipe, pelo formato markdown e pelo parâmetro tag.
    • Para uma comparação eficaz, o URL de entrada deve ser exatamente o mesmo da solicitação anterior para o mesmo conteúdo.
    • Rastear os mesmos URLs com includePaths/excludePaths diferentes pode gerar inconsistências ao usar changeTracking.
    • Raspar os mesmos URLs com includeTags/excludeTags/onlyMainContent diferentes pode gerar inconsistências ao usar changeTracking.
    • As páginas também serão comparadas com coletas anteriores que tenham apenas o formato markdown, sem o formato changeTracking.
    • As comparações são limitadas à sua equipe. Se você raspar um URL pela primeira vez com sua chave de API, o changeStatus será sempre new, mesmo que outros usuários do Firecrawl já o tenham raspado antes.
  • Status Beta: Enquanto estiver em Beta, recomenda-se monitorar o campo warning do documento resultante e tratar a possibilidade de o objeto changeTracking estar ausente na resposta.
    • Isso pode ocorrer quando a consulta ao banco de dados para localizar a coleta anterior para comparação excede o tempo limite.

​
Exemplos

​
Exemplo básico de scraping

// Requisição
{
    "url": "https://firecrawl.dev",
    "formats": ["markdown", "changeTracking"]
}

// Resposta
{
  "success": true,
  "data": {
    "markdown": "...",
    "metadata": {...},
    "changeTracking": {
      "previousScrapeAt": "2025-03-30T15:07:17.543071+00:00",
      "changeStatus": "same",
      "visibility": "visible"
    }
  }
}

​
Exemplo de Crawl

// Solicitação
{
    "url": "https://firecrawl.dev",
    "scrapeOptions": {
        "formats": ["markdown", "rastreioDeMudanças"]
    }
}

​
Acompanhando alterações no preço de produto

const result = await firecrawl.scrape('https://example.com/product', {
  formats: [
    'markdown',
    {
      type: 'changeTracking',
      modes: ['json'],
      schema: {
        type: 'object',
        properties: {
          price: { type: 'string' },
          availability: { type: 'string' }
        }
      }
    }
  ]
});

if (result.changeTracking.changeStatus === 'changed') {
  console.log(`Preço alterado de ${result.changeTracking.json.price.previous} para ${result.changeTracking.json.price.current}`);
}

​
Monitoramento de alterações de conteúdo com Git-Diff

const result = await firecrawl.scrape('https://example.com/blog', {
  formats: [
    'markdown',
    { type: 'changeTracking', modes: ['git-diff'] }
  ]
});

if (result.changeTracking.changeStatus === 'changed') {
  console.log('Alterações no conteúdo:');
  console.log(result.changeTracking.diff.text);
}

​
Cobrança

O recurso de rastreio de mudanças está em beta. Usar a funcionalidade básica de rastreio de mudanças e o modo git-diff não tem custo adicional. Porém, se você usar o modo json para comparação de dados estruturados, a extração da página custará 5 créditos por página.