Wie kann man mit Laravel Web Scraping betreiben?

Mit Laravel, kannst du eine Website in drei Schritten scrapen: Installiere ein Paket wie Symfony DomCrawler über Composer, eine Bestellung erstellen Artisan, und dann die Elemente auswählen HTML mit Wahlschaltern CSS.

Dieser Leitfaden zum Web-Scraping zeigt dir, wie du konkret vorgehen musst, mit PHP-Code gebrauchsfertig.

Voraussetzungen für das Scraping mit Laravel

Laravel ist ein PHP-Framework Entwickelt für moderne Webanwendungen. Dank seines umfangreichen Ökosystems eignet es sich ideal als Grundlage für die Erstellung eines übersichtlichen und leicht zu wartenden Web-Scraping-Projekts.

Bevor du loslegst, vergewissere dich, dass du die richtigen Voraussetzungen hast:

• Composer, den Abhängigkeitsmanager zur Installation der Pakete.
• Eine aktuelle Version von PHP kompatibel mit deiner Laravel-Version.
• Laravel installiert über composer create-project laravel/laravel mein-scraper.

Was die Kenntnisse angeht, reichen ein paar Grundlagen aus, um loszulegen:

• Die Grundlagen von PHP und den Aufbau einer Anwendung Laravel (Steuerungen, Straßen, Architektur MVC).
• Das Verständnis des HTML und das CSS-Selektoren um bestimmte Elemente einer Seite gezielt anzusprechen.
• Den Umgang damit beherrschen Composer über die Befehlszeile, um ein Paket zum Projekt hinzuzufügen.

Was das Crawling selbst betrifft, sind hier die Scraping-Tools die nützlichsten:

• Symfony DomCrawler + HttpClient : das derzeit führende Duo. Es lädt eine Seite herunter und navigiert mithilfe der Methode filter() aus DomCrawler. Um den Client zu initialisieren, verwendest du HttpClient::create() mit den gewünschten Optionen.
• HTTP Client von Laravel : basierend auf Guzzle, ruft er einen einfachen Inhalt mit Http::get() und verarbeitet Anrufe an eine API.
• Puppeteer / Headless Chrom : Ein Browser ohne Benutzeroberfläche, unverzichtbar zum Scrapen von Seiten, deren Inhalt über JavaScript oder über Ajax. Puppeteer Da es sich um ein Node.js-Tool handelt, steuerst du es über Laravel über das Paket spatie/browsershot.

Tutorial zum Erstellen des ersten Scrapers mit Laravel

Befolge diese Schritte, um ein funktionaler Scraper mit Laravel. Du wirst ein Scraping-Paket installieren und einen Befehl generieren Artisan, und anschließend die Daten mit CSS-Selektoren gezielt ansprechen.

Schritt 1: Installation und Konfiguration

Ein neues Projekt erstellen Laravel mit Composer, und füge dann die Komponenten hinzu Symfony Für das Scraping erforderlich:

# 1) Ein neues Laravel-Projekt erstellen
composer create-project laravel/laravel scraper-demo
cd scraper-demo

# 2) Die Scraping-Komponenten hinzufügen
composer require symfony/browser-kit symfony/http-client symfony/dom-crawler symfony/css-selector

Du wirst oft auf … stoßen Goutte Wo weidner/goutte in älteren Anleitungen. Diese Pakete werden offiziell nicht mehr unterstützt, und weidner/goutte lässt sich nicht mehr auf den neueren Versionen von Laravel (11 ff.).

Ihr direkter Nachfolger ist der HttpBrowser von Symfony, und der Code bleibt nahezu unverändert.

Schritt 2: Einen „Artisan“-Auftrag erstellen

Erstellt einen Befehl, der deine Scraping-Logik enthält, mit php artisan :

php artisan make:command ScrapeData

Die Datei wird hier erstellt : app/Console/Commands/ScrapeData.php. In diesem Klasse dass du die HTTP-Anfrage schreiben und die Daten extrahieren wirst. Die Klasse ScrapeData erstreckt sich Befehl, und die Methode public function handle() enthält die gesamte Scraping-Logik.

Schritt 3: Den Scraper-Code schreiben

In dem generierten Befehl wirst du drei wesentliche Bausteine zusammenfügen:

• A HTTP-Anfrage um den HTML-Inhalt der Seite abzurufen.
• Des CSS-Selektoren übergegangen in das DomCrawler um Daten über filter().
• A Schleife um die Elemente zu durchsuchen und die Ergebnisse anzuzeigen.

Hier ist ein vollständiges Codebeispiel zum Scrapen der Artikelüberschriften aus einem Blog:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Symfony\Component\BrowserKit\HttpBrowser;
use Symfony\Component\HttpClient\HttpClient;
use Symfony\Component\DomCrawler\Crawler;

class ScrapeData extends Command
{
    protected $signature = 'scrape:data';
    protected $description = 'Scraper simple des titres d\'articles';

    public function handle(): int
    {
        $url = 'https://example.com/blog'; // URL du blog à scraper
        $this->info("Scraping: {$url}");

        // 1) Requête HTTP pour récupérer le HTML
        $browser = new HttpBrowser(HttpClient::create());
        $crawler = $browser->request('GET', $url);

        // 2) Utilisation de sélecteurs CSS avec DomCrawler
        $nodes = $crawler->filter('h2 a');

        // 3) Boucle sur les éléments et affichage
        $nodes->each(function (Crawler $node, $i) {
            $title = $node->text();
            $link  = $node->attr('href');
            $this->line(($i+1) . ". " . $title . " - " . $link);
        });

        return self::SUCCESS;
    }
}

Hier, DomCrawler übernimmt die gesamte HTML-Analyse. Die Methode filter('h2 a') extrahiert jeden Link, der in einer Überschrift enthalten ist, und anschließend each() Schleife darüber, um das Text und das Attribut href. Starte anschließend den Scraper über dein Terminal mit php artisan scrape:data und du wirst sehen, wie die Titel nacheinander angezeigt werden.

Du kannst auch Folgendes ausführen: php artisan serve um deine Anwendung vor der Bereitstellung lokal zu testen.

Best Practices für das Web Scraping mit Laravel

Um mit Laravel sauber zu scrapen, machen ein paar kleine Kniffe den Unterschied. Hier sind die bewährten Vorgehensweisen, die du anwenden solltest, egal ob du ein Web-Scraping-Bot oder eine einmalige Bestellung.

1. Verwaltung von Aufgaben und Warteschlangen

Das Scraping kann mehrere Sekunden pro Seite. Stell dir vor, du müsstest scrapen 1000 Seiten einer Website: Deine App wäre für eine ganze Weile blockiert und unbrauchbar. Die Lösung lässt sich in zwei Worten zusammenfassen: die jobs und das Warteschlangen von Laravel.

• EIN Stelle, das ist eine Aufgabe, die du im Hintergrund ausführen möchtest.
• A Schwanz (Warteschlange) – das ist der Ort, an dem diese Aufträge abgelegt werden, um sie nach und nach auszuführen, ohne den Rest zu blockieren.

So bündeln Sie die Scraping-Logik in einem Job:

<?php
// app/Jobs/ScrapePageJob.php

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Symfony\Component\BrowserKit\HttpBrowser;
use Symfony\Component\HttpClient\HttpClient;

class ScrapePageJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected string $url;

    public function __construct(string $url)
    {
        $this->url = $url;
    }

    public function handle(): void
    {
        $client = new HttpBrowser(HttpClient::create());

        $crawler = $client-&gt;request('GET', $this-&gt;url);

        // Exemple simple : extraire tous les <h1>
        $titles = $crawler-&gt;filter('h1')-&gt;each(function ($node) {
            return $node-&gt;text();
        });

        // Persistenz / Logs / Events...
        foreach ($titles as $title) {
            \Log::info("[Scraping] {$this-&gt;url} - H1: {$title}");
        }
    }
}

onQueue('scraping'); // falls du eine eigene Warteschlange nutzen möchtest
 }

 return response()->json(['status' => 'Scraping im Hintergrund gestartet']);
    }
}

Um diesen Controller auszulösen, definiere eine Route in deiner Datei „routes/web.php“, zum Beispiel Route::get('/scrape', [ScraperController::class, 'start']). Du kannst auch einen eigenen Controller mit php artisan make:controller ScraperController.
Laravel bietet mehrere Systeme zur Verwaltung dieser Warteschlange an. Die beiden am häufigsten verwendeten sind:

• Datei mit Datenbank : Die Jobs werden als Zeilen in einer SQL-Tabelle gespeichert und anschließend nacheinander von einem Worker ausgeführt.
• Reihe mit Redis : Die Aufträge werden im Speicher in einer extrem schnellen Warteschlange abgelegt, was sich ideal für ein großes Aufgabenvolumen eignet.

2. Automatisierung mit dem Aufgabenplaner von Laravel

Laravel integriert einen Aufgabenplaner (Scheduler), mit dem du deine Scraper automatisieren kannst, ohne dir darüber Gedanken machen zu müssen. So kannst du beispielsweise die Ausführung eines Befehls in regelmäßigen Abständen planen, zum Beispiel jede Stunde.

So konfigurieren Sie es in „routes/console.php“:

hourly();

// Nützliche Beispiele:
// Schedule::command('scrape:data')->everyFifteenMinutes();
// Schedule::command('scrape:data')->dailyAt('02:30')->timezone('Indian/Antananarivo');

3. Umgehen von Anti-Scraping-Schutzmaßnahmen

Viele Websites haben Schutzmaßnahmen gegen Scraper eingerichtet. Um zu vermeiden, dass Sie blockiert werden:

• Den User-Agent ändern : Simuliert einen echten Browser anstelle des Standard-Headers des HTTP-Clients.
• Fristen verwalten : fügt Pausen ein (sleep, throttle) zwischen den Anfragen, um den Zielserver nicht zu überlasten.
• Proxys verwenden : Verteile die Anfragen auf mehrere IP-Adressen.

4. Die robots.txt-Datei und die rechtlichen Rahmenbedingungen beachten

Einen Schutz zu umgehen bedeutet nicht, einfach alles zu machen, was man will. Das Scraping unterliegt weiterhin bestimmten Regeln, und diese zu missachten, kann dich teuer zu stehen kommen.

• Beachtet die Datei „robots.txt“ : Er gibt an, welche Seiten die Website für das Crawling zulässt und welche nicht. Das ist die erste Höflichkeitsregel, die es zu beachten gilt.
• Lies dir die Nutzungsbedingungen durch : Eine Website kann das Scraping in ihren Nutzungsbedingungen untersagen.
• Denk an die DSGVO : Wenn du persönliche Daten, musst du die EU-Verordnung über die Erhebung und Verarbeitung dieser Daten einhalten.

Welche Alternativen gibt es zum Web Scraping mit Laravel?

Laravel eignet sich nach wie vor gut, um Scraping in eine PHP-Anwendung bestehende. Je nach deinem Projekt sind jedoch manchmal andere Lösungen besser geeignet. Hier sind die beiden wichtigsten Alternativen mit ihren Vorteilen und Einschränkungen.

Web-Scraping mit Python

Python ist die am häufigsten verwendete Sprache für das Scraping. Sie stützt sich auf ausgereifte Bibliotheken wie Scrapy und BeautifulSoup.

• Vorteile : sehr vielfältiges Ökosystem, native Verwaltung des Crawlings in großem Maßstab, riesige Community.
• Nachteile : Man muss das Laravel-Umfeld verlassen. Das ist etwas umständlich, wenn deine Website und deine API bereits auf PHP.

Konkret solltest du dich für Python entscheiden, wenn das Scraping den Kern des Projekts bildet und nicht nur ein Baustein deiner Anwendung ist.

Werkzeuge ohne Code

Es gibt immer mehr Tools, mit denen man Daten aus Websites extrahieren kann ohne zu codieren, manchmal mit Hilfe der’IA. Die bekanntesten sind Bright Data, Octoparse und Apify.

• Vorteile : visuelle Konfiguration, integrierte Verwaltung von JavaScript-Seiten und Blockierungen, keine Programmierarbeit erforderlich.
• Nachteile : kostenpflichtiges Abonnement, weniger Feinabstimmung als bei einem selbst entwickelten Scraper in Laravel.

Häufig gestellte Fragen

Wie kann man eine login-geschützte Website mit Laravel scrapen?

Das Prinzip ist einfach: Du simulierst eine Anmeldung und nutzt dann die Sitzung weiter, um auf die geschützten Seiten zuzugreifen. Konkret musst du Folgendes tun:

1. Verbindung simulieren mit einer POST-Anfrage, die die E-Mail-Adresse und das Passwort an das Formular übermittelt.
2. Cookies speichern Sitzungsdaten, damit die folgenden Anfragen weiterhin authentifiziert bleiben.

Mit dem HttpBrowser von Symfony, kannst du die beiden Schritte nahtlos aneinanderreihen. Er instanziiert den Client über HttpClient::create(), und verwaltet die Cookies anschließend automatisch zwischen den einzelnen Anfragen:

use Symfony\Component\BrowserKit\HttpBrowser;
use Symfony\Component\HttpClient\HttpClient;

$browser = new HttpBrowser(HttpClient::create());

$crawler = $browser->request('GET', 'https://exemple.com/login');
$form = $crawler->selectButton('Se connecter')->form();

$browser->submit($form, [
    'email'    => 'ton@email.com',
    'password' => 'ton_mot_de_passe',
]);

// Les cookies de session sont gardés automatiquement
$page = $browser->request('GET', 'https://exemple.com/compte');
echo $page->filter('h1')->text();

Beachten Sie: Der HttpBrowser verwaltet die Cookies zwischen zwei Anfragen selbstständig. Du musst also nichts manuell speichern.

Wie verwalte ich die Paginierung beim Web Scraping mit Laravel?

Um mehrere Seiten hintereinander zu durchblättern, muss man den Link «Nächste Seite» mit einem CSS-Selektor, und dann so lange eine Schleife zu durchlaufen, wie es existiert. Die Logik lautet wie folgt:

1. Die erste Seite scrapen und die relevanten Daten extrahieren.
2. Den Link «Weiter» erkennen» über einen CSS-Selektor.
3. Abschließen bis keine nächste Seite mehr vorhanden ist.

$url = 'https://exemple.com/blog?page=1';

while ($url) {
    $crawler = $browser->request('GET', $url);

    $crawler->filter('.article-title')->each(function ($node) {
        echo $node->text() . PHP_EOL;
    });

    // Récupère le lien "page suivante" s'il existe
    $next = $crawler->filter('a.next');
    $url  = $next->count() ? $next->attr('href') : null;
}

Diese Schleife beendet sich von selbst, sobald der Schalter a.next liefert keine Ergebnisse mehr.

Wie exportiert man die gesammelten Daten (als CSV, Excel oder JSON)?

Sobald du deine Daten abgerufen hast, kannst du sie mit Laravel in verschiedene Formate exportieren:

• fputcsv() um eine Datei zu erstellen CSV Muttersprachler.
• Die Buchhandlung Maatwebsite\Excel um eine Datei zu erstellen Excel.
• Die native Funktion json_encode() für einen Export JSON, was praktisch ist, wenn du deine Daten anschließend über eine API bereitstellst.

Wie gehe ich mit Fehlern und Ausnahmen während des Scrapings um?

Eine Website kann einen Fehler zurückgeben, ihre HTML-Struktur ändern oder die Verbindung unterbrechen. Für einen robusten Scraper musst du diese Fälle einkalkulieren:

1. Jede Anfrage kapseln in einem try/catch.
2. HTTP-Codes überprüfen (404, 429, 500…) und den Fehler protokollieren oder den Versuch nach einer gewissen Zeit erneut starten.

try {
    $crawler = $browser->request('GET', $url);
    $status  = $browser->getResponse()->getStatusCode();

    if ($status !== 200) {
        \Log::warning("Réponse inattendue: $status sur $url");
    }
} catch (\Exception $e) {
    \Log::error('Scraping échoué: ' . $e->getMessage());
}

Ist Web Scraping legal oder illegal?

Das Legalität von Web Scraping hängt von der jeweiligen Website und deiner Nutzung der Daten ab. Hier sind drei Punkte, die du beachten solltest:

• Sui-generis-Recht an Datenbanken : die Europäische Richtlinie 96/9/EG schützt den Inhalt einer Datenbank. Das Extrahieren eines wesentlichen Teils einer Website kann untersagt sein.
• Nutzungsbedingungen : Das Urteil „Ryanair gegen PR Aviation“ (EuGH, 2015) hat bestätigt, dass eine Website in ihren Nutzungsbedingungen das Scraping untersagen kann, wenn ihre Datenbank weder durch das Urheberrecht noch durch das Sui-generis-Recht geschützt ist.
• DSGVO : Sobald du persönliche Daten (E-Mails, Namen, Profile) – dann fällst du unter die europäische Verordnung. Sei äußerst vorsichtig.

In der Praxis solltest du dich immer an die Datei halten robots.txt, beschränke die Häufigkeit deiner Anfragen und vermeide die Erhebung personenbezogener Daten ohne Rechtsgrundlage. Hast du eine Frage oder einen Sonderfall? Schreibe es in die Kommentare.