Raspagem da Web com Goutte em PHP: Tutorial 2025

#hockey .table

Aplique o seletor CSS para selecionar o nó da tabela usando o método $crawler->filter():

$table = $crawler->filter("#hockey .table");

Em seguida, observe que cada linha é representada por um elemento

    $table->filter("tr.team")->each(function ($tr) use (&$teams) {
      // data extraction logic...
    });

Maravilhoso! Agora você tem um esqueleto pronto para a coleta de dados do Goutte.

Etapa nº 5: implementar a lógica de extração de dados

Assim como antes, desta vez inspecione as linhas dentro da tabela:

O que você pode notar é que cada linha contém as seguintes informações em colunas dedicadas:

• Nome da equipe → dentro do elemento .name
• Ano da estação → dentro do elemento .year
• Número de vitórias → dentro do elemento .wins
• Número de perdas → dentro do elemento .losses
• Perdas com horas extras → dentro do elemento .ot-losses
• Porcentagem de vitórias → dentro do elemento .pct
• Gols marcados (Goals For – GF) → dentro do elemento .gf
• Gols sofridos (Gols contra – GA) → dentro do elemento .ga
• Diferença de gols → dentro do elemento .diff

Para recuperar uma única informação, você precisa aplicar essas duas etapas:

1. Selecione o elemento HTML usando filter()
2. Extraia seu conteúdo de texto usando o método text() e remova todos os espaços extras com trim()

Por exemplo, você pode extrair o nome da equipe com:

$teamElement = $tr->filter(".name");
$team = trim($teamElement->text());

Da mesma forma, estenda essa lógica a todas as outras colunas:

$yearElement = $tr->filter(".year");
$year = trim($yearElement->text());

$winsElement = $tr->filter(".wins");
$wins = trim($winsElement->text());

$lossesElement = $tr->filter(".losses");
$losses = trim($lossesElement->text());

$otLossesElement = $tr->filter(".ot-losses");
$otLosses = trim($otLossesElement->text());

$pctElement = $tr->filter(".pct");
$pct = trim($pctElement->text());

$gfElement = $tr->filter(".gf");
$gf = trim($gfElement->text());

$gaElement = $tr->filter(".ga");
$ga = trim($gaElement->text());

$diffElement = $tr->filter(".diff");
$diff = trim($diffElement->text());

Depois de extrair os dados de interesse da linha, armazene-os na matriz $teams:

$teams[] = [
  "team" => $team,
  "year" => $year,
  "wins" => $wins,
  "losses" => $losses,
  "ot_losses" => $otLosses,
  "win_perc" => $pct,
  "goals_for" => $gf,
  "goals_against" => $ga,
  "goal_diff" => $diff
];

Depois de percorrer todas as linhas, o array $teams conterá:

Array
(
    [0] => Array
        (
            [team] => Boston Bruins
            [year] => 1990
            [wins] => 44
            [losses] => 24
            [ot_losses] =>
            [win_perc] => 0.55
            [goals_for] => 299
            [goals_against] => 264
            [goal_diff] => 35
        )

    // ...

    [24] => Array
        (
            [team] => Chicago Blackhawks
            [year] => 1991
            [wins] => 36
            [losses] => 29
            [ot_losses] =>
            [win_perc] => 0.45
            [goals_for] => 257
            [goals_against] => 236
            [goal_diff] => 21
        )
)

Excelente! A raspagem de dados da Goutte foi realizada com sucesso.

Etapa nº 6: implementar a lógica de rastreamento

Agora, não se esqueça de que o site de destino apresenta dados em várias páginas, mostrando apenas uma parte de cada vez. Abaixo da tabela, há um elemento de paginação que fornece links para todas as páginas:

Portanto, você pode gerenciar a paginação em seu script de raspagem com estas etapas simples:

1. Selecione os elementos do link de paginação
2. Extrair os URLs das páginas paginadas
3. Visite cada página e aplique a lógica de raspagem desenvolvida anteriormente

Comece inspecionando os elementos do link de paginação:

Observe que você pode selecionar todos os links de paginação usando o seletor CSS a seguir:

.pagination li a

Para implementar a etapa 2 e coletar todos os URLs de paginação, use esta lógica:

$urls = [$url];

// select the pagination link elements
$crawler->filter(".pagination li a")->each(function ($a) use (&$urls) {
  // construct the absolute URL
  $url = "https://www.scrapethissite.com" . $a->attr("href");

  // add the pagination URL to the list only if it is not already present
  if (!in_array($url, $urls)) {
    $urls[] = $url;
  }
});

Isso inicializa uma lista de URLs que armazenará os links de paginação, começando com o URL da primeira página. Em seguida, seleciona todos os elementos de paginação e itera sobre eles, adicionando novos URLs à matriz $urls somente se eles ainda não estiverem presentes. Como os URLs na página são relativos, eles devem ser convertidos em URLs absolutos antes de serem adicionados à lista.

Como o tratamento da paginação só deve ser executado uma vez e não está diretamente ligado à extração de dados, é melhor envolvê-lo em uma função:

function getPaginationUrls($client, $url)
{
  // connect to the first page of the site
  $crawler = $client->request("GET", $url);

  // initialize the list of URLs to scrape with the current URL
  $urls = [$url];

  // select the pagination link elements
  $crawler->filter(".pagination li a")->each(function ($a) use (&$urls) {
    // construct the absolute URL
    $url = "https://www.scrapethissite.com" . $a->attr("href");

    // add the pagination URL to the list only if it is not already present
    if (!in_array($url, $urls)) {
      $urls[] = $url;
    }
  });

  return $urls;
}

Você pode chamar a função getPaginationUrls() da seguinte forma:

$urls = getPaginationUrls($client, "https://www.scrapethissite.com/pages/forms/?page_num=1");

Após a execução, $urls conterá todas as URLs paginadas:

Array
(
    [0] => https://www.scrapethissite.com/pages/forms/?page_num=1
    [1] => https://www.scrapethissite.com/pages/forms/?page_num=2
    [2] => https://www.scrapethissite.com/pages/forms/?page_num=3
    [3] => https://www.scrapethissite.com/pages/forms/?page_num=4
    [4] => https://www.scrapethissite.com/pages/forms/?page_num=5
    [5] => https://www.scrapethissite.com/pages/forms/?page_num=6
    [6] => https://www.scrapethissite.com/pages/forms/?page_num=7
    [7] => https://www.scrapethissite.com/pages/forms/?page_num=8
    [8] => https://www.scrapethissite.com/pages/forms/?page_num=9
    [9] => https://www.scrapethissite.com/pages/forms/?page_num=10
    [10] => https://www.scrapethissite.com/pages/forms/?page_num=11
    [11] => https://www.scrapethissite.com/pages/forms/?page_num=12
    [12] => https://www.scrapethissite.com/pages/forms/?page_num=13
    [13] => https://www.scrapethissite.com/pages/forms/?page_num=14
    [14] => https://www.scrapethissite.com/pages/forms/?page_num=15
    [15] => https://www.scrapethissite.com/pages/forms/?page_num=16
    [16] => https://www.scrapethissite.com/pages/forms/?page_num=17
    [17] => https://www.scrapethissite.com/pages/forms/?page_num=18
    [18] => https://www.scrapethissite.com/pages/forms/?page_num=19
    [19] => https://www.scrapethissite.com/pages/forms/?page_num=20
    [20] => https://www.scrapethissite.com/pages/forms/?page_num=21
    [21] => https://www.scrapethissite.com/pages/forms/?page_num=22
    [22] => https://www.scrapethissite.com/pages/forms/?page_num=23
    [23] => https://www.scrapethissite.com/pages/forms/?page_num=24
)

Perfeito! Você acabou de implementar o rastreamento da Web no Goutte.

Etapa nº 7: Extraia dados de todas as páginas

Agora que você tem todos os URLs de página armazenados em uma matriz, pode extraí-los um a um:

1. Iteração sobre a lista
2. Recuperação e análise do conteúdo HTML de cada URL
3. Extração dos dados necessários
4. Armazenamento das informações extraídas na matriz $teams.

Implemente a lógica acima da seguinte forma:

$teams = [];

// iterate over all pages and scrape them all
foreach ($urls as $_ => $url) {
  // logging which page the scraper is currently working on
  echo "Scraping webpage \"$url\"...\n";

  // retrieve the HTML of the current page and parse it
  $crawler = $client->request("GET", $url);

  // $table = $crawler-> ...
  // data extraction logic
}

Observe a instrução echo para registrar a página atual em que o scraper está operando. Essa informação é útil para entender o que o script está fazendo durante a execução.

Que lindo! Só falta exportar os dados extraídos para um formato legível por humanos, como CSV.

Etapa 8: Exportar os dados extraídos para CSV

No momento, os dados extraídos são armazenados na matriz $teams. Para torná-los acessíveis a outras equipes e mais fáceis de analisar, exporte-os para um arquivo CSV.

O PHP oferece suporte integrado para exportação de CSV por meio da função fputcsv(). Use-a para gravar os dados extraídos em um arquivo chamado teams.csv, conforme abaixo:

// open the output file for writing
$file = fopen("teams.csv", "w");

// write the header row
fputcsv($file, ["Team Name", "Year", "Wins", "Losses", "OT Losses", "Win %","Goals For (GF)",        "Goals Against (GA)", "+ / -"]);

// append each team as a new row
foreach ($teams as $team) {
  fputcsv($file, [
    $team["team"],
    $team["year"],
    $team["wins"],
    $team["losses"],
    $team["ot_losses"],
    $team["win_perc"],
    $team["goals_for"],
    $team["goals_against"],
    $team["goal_diff"]
  ]);
}

// close the file
fclose($file);

Missão concluída! O raspador Goutte está totalmente funcional.

Etapa nº 9: Juntar tudo

Seu script de raspagem da Web do Goutte deve conter agora:

<?php

require_once __DIR__ . "/vendor/autoload.php";

use Goutte\Client;

function getPaginationUrls($client, $url)
{
  // connect to the first page of the site
  $crawler = $client->request("GET", $url);

  // initialize the list of URLs to scrape with the current URL
  $urls = [$url];

  // select the pagination link elements
  $crawler->filter(".pagination li a")->each(function ($a) use (&$urls) {
    // construct the absolute URL
    $url = "https://www.scrapethissite.com" . $a->attr("href");

    // add the pagination URL to the list only if it is not already present
    if (!in_array($url, $urls)) {
      $urls[] = $url;
    }
  });

  return $urls;
}

// initialize a new Goutte HTTP client
$client = new Client();

// get the URLs of the pages to scrape
$urls = getPaginationUrls($client, "https://www.scrapethissite.com/pages/forms/?page_num=1");

// where to store the scraped data
$teams = [];

// iterate over all pages and scrape them all
foreach ($urls as $_ => $url) {
  // logging which page the scraper is currently working on
  echo "Scraping webpage \"$url\"...\n";

  // retrieve the HTML of the current page and parse it
  $crawler = $client->request("GET", $url);

  // select the table element with the data of interest
  $table = $crawler->filter("#hockey .table");

  // iterate over each row and extract data from them
  $table->filter("tr.team")->each(function ($tr) use (&$teams) {
    // data extraction logic

    $teamElement = $tr->filter(".name");
    $team = trim($teamElement->text());

    $yearElement = $tr->filter(".year");
    $year = trim($yearElement->text());

    $winsElement = $tr->filter(".wins");
    $wins = trim($winsElement->text());

    $lossesElement = $tr->filter(".losses");
    $losses = trim($lossesElement->text());

    $otLossesElement = $tr->filter(".ot-losses");
    $otLosses = trim($otLossesElement->text());

    $pctElement = $tr->filter(".pct");
    $pct = trim($pctElement->text());

    $gfElement = $tr->filter(".gf");
    $gf = trim($gfElement->text());

    $gaElement = $tr->filter(".ga");
    $ga = trim($gaElement->text());

    $diffElement = $tr->filter(".diff");
    $diff = trim($diffElement->text());

    // add the scraped data to the array
    $teams[] = [
      "team" => $team,
      "year" => $year,
      "wins" => $wins,
      "losses" => $losses,
      "ot_losses" => $otLosses,
      "win_perc" => $pct,
      "goals_for" => $gf,
      "goals_against" => $ga,
      "goal_diff" => $diff
    ];
  });
}

// open the output file for writing
$file = fopen("teams.csv", "w");

// write the header row
fputcsv($file, ["Team Name", "Year", "Wins", "Losses", "OT Losses", "Win %","Goals For (GF)",        "Goals Against (GA)", "+ / -"]);

// append each team as a new row
foreach ($teams as $team) {
  fputcsv($file, [
    $team["team"],
    $team["year"],
    $team["wins"],
    $team["losses"],
    $team["ot_losses"],
    $team["win_perc"],
    $team["goals_for"],
    $team["goals_against"],
    $team["goal_diff"]
  ]);
}

// close the file
fclose($file);

Inicie-o com este comando:

php index.php

O raspador registraria a seguinte saída:

Scraping webpage "https://www.scrapethissite.com/pages/forms/?page_num=1"...
// omitted for brevity..
Scraping webpage "https://www.scrapethissite.com/pages/forms/?page_num=24"...

No final da execução, um arquivo teams.csv contendo esses dados aparecerá na pasta do projeto:

E pronto! Os dados exatos do site de destino agora estão disponíveis em um formato estruturado.

Alternativas à biblioteca PHP Goutte para raspagem da Web

Conforme mencionado no início deste artigo, o Goutte está obsoleto e não é mais mantido. Isso significa que você deve considerar soluções alternativas.

Conforme explicado no GitHub, como o Goutte v4 se tornou essencialmente um proxy para a classe HttpBrowser do Symfony, você deve migrar para ele. Para isso, você só precisa instalar essas bibliotecas:

composer require symfony/browser-kit symfony/http-client

Em seguida, substitua:

use Goutte\Client;

com

use Symfony\Component\BrowserKit\HttpBrowser;

Por fim, remova o Goutte como uma dependência em seu projeto. A API subjacente permanece a mesma, portanto, você não deve precisar alterar muito em seu script.

Em vez do Goutte, você também pode combinar um cliente HTTP com um analisador de HTML. Algumas alternativas recomendadas:

• Guzzle ou cURL para fazer solicitações HTTP.
• Dom\HTMLDocument, Simple HTML DOM Parser ou DomCrawler para analisar HTML em PHP.

Todas essas alternativas oferecem mais flexibilidade e garantem que seu script de raspagem da Web permaneça sustentável a longo prazo.

Limitações dessa abordagem de raspagem da Web

O Goutte é uma ferramenta avançada, mas seu uso para raspagem da Web tem várias limitações:

• A biblioteca está obsoleta
• Sua API não é mais mantida
• Ele está sujeito a limitadores de taxa e bloqueios antirrastreamento
• Ele não pode lidar com páginas dinâmicas que dependem de JavaScript
• Ele tem suporte limitado a proxy integrado, o que é essencial para evitar proibições de IP

Algumas dessas limitações podem ser atenuadas com o uso de bibliotecas alternativas ou abordagens diferentes, conforme abordado em nosso guia sobre raspagem da Web com PHP. Ainda assim, você sempre enfrentará medidas antirrastreamento que só podem ser contornadas usando uma API do Web Unlocker.

Uma API do Web Unlocker é um ponto de extremidade de raspagem especializado, projetado para contornar as proteções antibot e recuperar o HTML bruto de qualquer página da Web. Usá-la é tão simples quanto fazer uma chamada à API e analisar o conteúdo retornado. Essa abordagem se integra perfeitamente ao Goutte (ou aos componentes atualizados do Symfony), conforme demonstrado neste artigo.

Conclusão

Neste guia, você explorou o que é o Goutte e o que ele oferece para raspagem da Web por meio de um tutorial passo a passo. Como essa biblioteca está obsoleta, você também teve a oportunidade de explorar algumas de suas alternativas.

Independentemente da biblioteca de raspagem PHP que você escolher, o maior desafio é que a maioria dos sites protege seus dados usando tecnologias anti-bot e anti-raspagem. Esses mecanismos podem detectar e bloquear solicitações automatizadas, tornando ineficazes os métodos tradicionais de raspagem.

Felizmente, a Bright Data oferece um conjunto de soluções para evitar qualquer problema:

• Web Unlocker: Uma API que contorna as proteções antirrastreamento e fornece HTML limpo de qualquer página da Web com o mínimo de esforço.
• Navegador de raspagem: Um navegador controlável e baseado em nuvem com renderização de JavaScript. Ele lida automaticamente com CAPTCHAs, impressão digital do navegador, novas tentativas e muito mais para você. Integra-se perfeitamente ao Panther ou ao Selenium PHP.
• APIs de raspagem da Web: Endpoints para acesso programático a dados estruturados da Web de dezenas de domínios populares.

Não quer lidar com raspagem da Web, mas ainda está interessado em “dados on-line da Web”? Explore nossos conjuntos de dados prontos para uso!

Inscreva-se agora na Bright Data e comece sua avaliação gratuita para testar nossas soluções de raspagem.