Scraper pour WordPress

Le web scraping est l'un des outils les plus demandés pour les sites WordPress. Il permet d'alimenter automatiquement un site en contenu à jour : taux de change, actualités, prévisions météo, produits de fournisseurs et bien plus encore. Dans cet article, nous passons en revue les plugins existants, les cas où il vaut mieux écrire son propre scraper en PHP, et nous examinons quatre scénarios pratiques d'intégration du scraping dans WordPress.

Si vous souhaitez approfondir la technologie d'extraction de données elle-même, nous vous recommandons l'article dédié « Scraper en PHP », qui décrit en détail les principes de fonctionnement, les bibliothèques (cURL, Guzzle, Simple HTML DOM, Symfony DomCrawler) et les pièges classiques. Ici, nous mettons l'accent précisément sur l'intégration avec WordPress.

Qu'est-ce que le scraping dans le contexte de WordPress

Le web scraping est la collecte automatique de données depuis des sources externes : sites web, API, flux RSS, catalogues de prix. Dans WordPress, ces données ne doivent généralement pas seulement être récupérées, mais aussi :

• enregistrées en base de données (comme articles, produits, champs méta ou options) ;
• mises en cache, pour ne surcharger ni la source externe ni votre propre serveur ;
• mises à jour selon un calendrier (via wp_cron ou le cron système) ;
• affichées sur le front-end (via des shortcodes, des widgets ou des blocs Gutenberg).

C'est pourquoi un « scraper pour WordPress » n'est pas un simple script qui télécharge quelque chose, mais un véritable module intégré à l'écosystème du CMS.

Panorama des plugins existants

Avant d'écrire votre propre solution, il est judicieux d'évaluer les plugins disponibles. Ils couvrent de nombreux besoins courants sans une seule ligne de code.

WP All Import

L'un des outils d'import les plus puissants. Il accepte le XML, le CSV et les formats de catalogues de prix, permet de faire correspondre visuellement (mapping) les champs de la source avec ceux des articles, des produits WooCommerce ou des utilisateurs. Il prend en charge l'import planifié et la mise à jour des enregistrements déjà importés. Il convient bien au scénario des produits de fournisseur, mais exige que la source fournisse un flux structuré.

Points forts : mapping flexible, interface conviviale, mise à jour fiable. Points faibles : les fonctionnalités avancées sont réservées à la version payante ; il ne « scrape » pas des pages HTML arbitraires sans flux préparé.

Content Egg

Un plugin agrégateur pour le marketing d'affiliation et de contenu : il sait récupérer produits, prix, avis et autres contenus depuis de nombreuses sources et API. Il est souvent utilisé pour la comparaison de prix et l'enrichissement des fiches.

Points forts : de nombreux modules sources prêts à l'emploi, des modèles d'affichage. Points faibles : conçu pour des scénarios précis (affiliation, marketplaces), avec sa propre logique d'affichage.

WP RSS Aggregator / Feedzy

Des plugins spécialisés dans l'import de flux RSS et Atom. Ils permettent de combiner plusieurs flux, de filtrer par mots-clés et de transformer les éléments du flux en articles WordPress.

Points forts : configuration simple pour les actualités et le RSS, filtrage et déduplication. Points faibles : limités au format de flux — ils ne conviennent pas pour du HTML arbitraire.

Scrapers universels (WP Content Pilot, plugins de scraping)

Il existe des plugins capables d'extraire des données de pages arbitraires à l'aide de sélecteurs CSS. Ce sont ceux qui se rapprochent le plus d'un « vrai » scraper, mais le moindre changement de mise en page de la source casse la configuration, et il est difficile d'y implémenter une logique de post-traitement complexe.

Quand les plugins ne suffisent plus

Les solutions clés en main fonctionnent très bien tant que votre besoin reste standard. Mais dès qu'apparaissent une source atypique, une logique de transformation complexe, une authentification côté fournisseur ou des exigences de cache spécifiques, la flexibilité du plugin atteint ses limites. C'est alors qu'on écrit son propre scraper.

Votre propre scraper PHP au sein de WordPress

Le principal avantage d'une solution maison est le contrôle total. Vous décidez vous-même comment récupérer les données, comment les nettoyer, où les stocker et quand les mettre à jour. WordPress fournit pour cela une boîte à outils pratique, et il n'est pas du tout nécessaire d'utiliser un file_get_contents « brut ».

Les « briques » de base sur lesquelles repose tout scraper pour WordPress :

// 1. Récupération des données — via l'API HTTP intégrée de WordPress
$response = wp_remote_get( 'https://example.com/data', array(
    'timeout' => 15,
    'headers' => array( 'User-Agent' => 'MySiteBot/1.0' ),
) );

if ( is_wp_error( $response ) ) {
    error_log( 'Erreur de requête : ' . $response->get_error_message() );
    return;
}

$body = wp_remote_retrieve_body( $response );

// 2. Mise en cache — via la Transients API, pour ne pas solliciter la source à chaque affichage
function my_get_cached_data() {
    $cache_key = 'my_parser_data';
    $data = get_transient( $cache_key );

    if ( false === $data ) {
        $data = my_fetch_and_parse(); // votre fonction de scraping
        set_transient( $cache_key, $data, HOUR_IN_SECONDS );
    }

    return $data;
}

// 3. Mise à jour planifiée — via WP-Cron
add_action( 'init', function () {
    if ( ! wp_next_scheduled( 'my_parser_update' ) ) {
        wp_schedule_event( time(), 'hourly', 'my_parser_update' );
    }
} );

add_action( 'my_parser_update', 'my_fetch_and_parse' );

L'analyse détaillée des bibliothèques de parsing HTML, de la gestion des encodages, du contournement des protections et de la construction d'un scraper robuste fait l'objet d'un article séparé : « Scraper en PHP ». Ci-dessous, nous nous appuyons sur ces principes et montrons précisément les spécificités WordPress.

Passons maintenant aux scénarios concrets.

Scénario 1. Scraping des taux de change

Un besoin classique d'une boutique en ligne ou d'un site d'information : afficher les prix dans plusieurs devises à la fois et les convertir automatiquement. La source est constituée des données officielles de la banque centrale (par exemple, le site de la banque centrale, qui fournit les taux en XML).

La logique est simple : une fois par jour, nous récupérons le XML des taux, nous le parsons, nous l'enregistrons dans les options WordPress et nous l'utilisons lors de l'affichage des prix.

function parse_currency_rates() {
    $url = 'https://example-cbr.ru/scripts/XML_daily.asp'; // lien abstrait vers la banque centrale
    $response = wp_remote_get( $url, array( 'timeout' => 15 ) );

    if ( is_wp_error( $response ) ) {
        return;
    }

    $xml = simplexml_load_string( wp_remote_retrieve_body( $response ) );
    if ( false === $xml ) {
        return;
    }

    $rates = array();
    foreach ( $xml->Valute as $valute ) {
        $code  = (string) $valute->CharCode;          // USD, EUR ...
        $value = (float) str_replace( ',', '.', $valute->Value );
        $nominal = (int) $valute->Nominal;
        $rates[ $code ] = $value / $nominal;          // taux pour 1 unité
    }

    update_option( 'my_currency_rates', $rates );
    update_option( 'my_currency_rates_updated', current_time( 'mysql' ) );
}
add_action( 'my_currency_update', 'parse_currency_rates' );

Conversion d'un prix dans la devise souhaitée :

function convert_price( $rub_amount, $currency = 'USD' ) {
    $rates = get_option( 'my_currency_rates', array() );
    if ( empty( $rates[ $currency ] ) ) {
        return $rub_amount;
    }
    return round( $rub_amount / $rates[ $currency ], 2 );
}

Et un shortcode pour afficher le taux sur une page :

add_shortcode( 'currency_rate', function ( $atts ) {
    $atts  = shortcode_atts( array( 'code' => 'USD' ), $atts );
    $rates = get_option( 'my_currency_rates', array() );
    $code  = strtoupper( $atts['code'] );

    return isset( $rates[ $code ] )
        ? esc_html( number_format( $rates[ $code ], 2 ) . ' ₽' )
        : '—';
} );
// Utilisation : [currency_rate code="EUR"]

L'analyse complète des formats XML/JSON des banques centrales, de la gestion de plusieurs devises et du calcul des taux croisés est traitée dans l'article dédié « Scraping des taux de change ».

Scénario 2. Scraping d'actualités et de flux RSS

Le deuxième scénario populaire est l'alimentation automatique du site en actualités. Ici, WordPress offre un bonus appréciable : le cœur du CMS contient déjà un parseur de flux intégré, fetch_feed(), basé sur la bibliothèque SimplePie. C'est le moyen le plus fiable de travailler avec le RSS sans réinventer la roue.

function import_news_from_rss( $feed_url ) {
    include_once ABSPATH . WPINC . '/feed.php';

    $feed = fetch_feed( $feed_url );
    if ( is_wp_error( $feed ) ) {
        return;
    }

    $max_items = $feed->get_item_quantity( 10 );
    $items     = $feed->get_items( 0, $max_items );

    foreach ( $items as $item ) {
        $guid = $item->get_id();

        // Protection contre les doublons — on cherche un article avec le même GUID source
        $existing = get_posts( array(
            'meta_key'   => '_source_guid',
            'meta_value' => $guid,
            'post_type'  => 'post',
            'fields'     => 'ids',
        ) );
        if ( $existing ) {
            continue;
        }

        $post_id = wp_insert_post( array(
            'post_title'   => sanitize_text_field( $item->get_title() ),
            'post_content' => wp_kses_post( $item->get_content() ),
            'post_date'    => $item->get_date( 'Y-m-d H:i:s' ),
            'post_status'  => 'draft', // en modération, pour éviter le contenu indésirable
            'post_type'    => 'post',
        ) );

        if ( $post_id && ! is_wp_error( $post_id ) ) {
            update_post_meta( $post_id, '_source_guid', $guid );
        }
    }
}

Nous lançons l'import selon un calendrier :

add_action( 'my_news_import', function () {
    import_news_from_rss( 'https://example.com/feed/' );
} );

Si la source ne fournit pas de RSS et qu'il faut extraire les actualités directement depuis la page HTML à l'aide de sélecteurs, il s'agit alors d'un véritable web scraping avec analyse de la mise en page. Nous réalisons ce type de projets clés en main dans le cadre de notre service d'extraction d'articles de presse : nous configurons l'extraction des titres, dates, images et textes depuis des sites arbitraires en tenant compte de leur structure.

Les subtilités du travail avec les flux, les formats RSS 2.0 et Atom, le filtrage et la fusion de plusieurs sources sont abordés dans un article dédié au RSS.

Scénario 3. Scraping des prévisions météo

Le widget météo est une demande fréquente pour les portails régionaux, les sites d'hôtels et les agences de voyage. Les données proviennent généralement d'une API météo qui renvoie du JSON. Dans le contexte de WordPress, l'objectif est d'intégrer proprement ce widget au site : récupérer les prévisions, les mettre en cache pour une courte durée et les afficher via un shortcode ou un bloc.

function get_weather( $city = 'Moscow' ) {
    $cache_key = 'weather_' . sanitize_key( $city );
    $weather   = get_transient( $cache_key );

    if ( false !== $weather ) {
        return $weather; // on renvoie depuis le cache
    }

    $url = add_query_arg( array(
        'q'     => $city,
        'units' => 'metric',
        'lang'  => 'ru',
        'appid' => 'YOUR_API_KEY',
    ), 'https://api.example-weather.com/data/forecast' );

    $response = wp_remote_get( $url, array( 'timeout' => 10 ) );
    if ( is_wp_error( $response ) ) {
        return null;
    }

    $data = json_decode( wp_remote_retrieve_body( $response ), true );

    $weather = array(
        'temp'        => $data['main']['temp'] ?? null,
        'description' => $data['weather'][0]['description'] ?? '',
        'icon'        => $data['weather'][0]['icon'] ?? '',
    );

    // La météo change souvent — on met en cache pour 30 minutes
    set_transient( $cache_key, $weather, 30 * MINUTE_IN_SECONDS );

    return $weather;
}

Un shortcode pour insérer le widget dans n'importe quel article ou page :

add_shortcode( 'weather', function ( $atts ) {
    $atts    = shortcode_atts( array( 'city' => 'Moscow' ), $atts );
    $weather = get_weather( $atts['city'] );

    if ( empty( $weather ) ) {
        return '<span class="weather-error">Météo indisponible</span>';
    }

    return sprintf(
        '<div class="weather-widget">
            <span class="weather-city">%s</span>
            <span class="weather-temp">%s°C</span>
            <span class="weather-desc">%s</span>
        </div>',
        esc_html( $atts['city'] ),
        esc_html( round( $weather['temp'] ) ),
        esc_html( $weather['description'] )
    );
} );
// Utilisation : [weather city="Saint Petersburg"]

Les points clés spécifiques à WordPress : un TTL de cache court (la météo se périme vite), un affichage via shortcode/widget et un échappement systématique des données avant affichage.

Pour un guide complet des sources de données météo, du parsing des prévisions sur plusieurs jours et de la gestion de la géolocalisation, consultez l'article sur le scraping des prévisions météo — ici, nous l'avons abordé précisément sous l'angle de l'intégration dans un site WordPress.

Scénario 4. Scraping du site d'un fournisseur et import de produits dans WooCommerce

Le scénario le plus complet : l'alimentation automatique d'une boutique en ligne avec les produits d'un fournisseur. La source peut être un catalogue de prix (CSV/XML/YML) ou le site du fournisseur lui-même, qu'il faut alors parser en HTML. Le résultat est importé dans WooCommerce sous forme de produits avec prix, stocks, images et catégories.

Examinons l'import depuis un flux structuré (la variante la plus robuste) :

function import_supplier_products() {
    // Protection contre les exécutions parallèles
    if ( get_transient( 'import_lock' ) ) {
        return;
    }
    set_transient( 'import_lock', 1, 10 * MINUTE_IN_SECONDS );

    $response = wp_remote_get( 'https://supplier.example.com/price.xml', array(
        'timeout' => 60,
    ) );

    if ( is_wp_error( $response ) ) {
        delete_transient( 'import_lock' );
        return;
    }

    $xml = simplexml_load_string( wp_remote_retrieve_body( $response ) );

    foreach ( $xml->offer as $offer ) {
        $sku   = (string) $offer->sku;
        $name  = (string) $offer->name;
        $price = (float) $offer->price;
        $stock = (int) $offer->stock;

        upsert_product( $sku, $name, $price, $stock, (string) $offer->picture );
    }

    delete_transient( 'import_lock' );
}

La fonction « créer ou mettre à jour » un produit (upsert) : elle recherche le produit par référence (SKU) et met à jour l'existant ou en crée un nouveau :

function upsert_product( $sku, $name, $price, $stock, $image_url = '' ) {
    $product_id = wc_get_product_id_by_sku( $sku );

    if ( $product_id ) {
        // Le produit existe déjà — on ne met à jour que le prix et le stock
        $product = wc_get_product( $product_id );
    } else {
        // Nouveau produit
        $product = new WC_Product_Simple();
        $product->set_sku( $sku );
        $product->set_name( $name );

        // L'image n'est téléchargée qu'à la création
        if ( $image_url ) {
            $attach_id = media_sideload_image( $image_url, 0, $name, 'id' );
            if ( ! is_wp_error( $attach_id ) ) {
                $product->set_image_id( $attach_id );
            }
        }
    }

    $product->set_regular_price( (string) $price );
    $product->set_stock_quantity( $stock );
    $product->set_manage_stock( true );
    $product->set_stock_status( $stock > 0 ? 'instock' : 'outofstock' );

    $product->save();
}

Lancement de l'import selon un calendrier (par exemple, deux fois par jour) :

add_action( 'init', function () {
    if ( ! wp_next_scheduled( 'supplier_import_event' ) ) {
        wp_schedule_event( time(), 'twicedaily', 'supplier_import_event' );
    }
} );
add_action( 'supplier_import_event', 'import_supplier_products' );

Points de vigilance dans ce scénario :

• Identification par SKU. La référence est la clé la plus fiable pour faire correspondre les produits entre le fournisseur et la boutique.
• Les images ne sont téléchargées qu'une seule fois. media_sideload_image() est une opération coûteuse ; inutile de la répéter à chaque mise à jour.
• Traitement par lots. Les gros catalogues (des dizaines de milliers de références) sont à traiter par lots (batch) pour ne pas se heurter aux limites de temps et de mémoire de PHP.
• Dépublication. Les produits disparus du catalogue du fournisseur doivent plutôt passer au statut « en rupture de stock » qu'être supprimés.

Si le fournisseur ne fournit pas de flux et qu'il faut parser les fiches produits directement depuis les pages HTML de son site, la tâche devient plus lourde et comporte ses propres subtilités (pagination, chargement dynamique, protection anti-bots). Les principes de ce type de parsing sont décrits en détail dans l'article « Scraper en PHP ».

Recommandations techniques

Quelques règles universelles qui rendront n'importe quel scraper pour WordPress plus fiable :

1. Utilisez l'API HTTP de WordPress (wp_remote_get/wp_remote_post) plutôt que file_get_contents ou du cURL « brut » — elle prend en compte les réglages de proxy, les timeouts et les filtres du CMS.
2. Mettez en cache via la Transients API. Cela réduit la charge à la fois sur votre serveur et sur la source.
3. Ne scrapez pas à la volée au chargement de la page. Le scraping lourd doit s'exécuter en arrière-plan via cron, tandis que le front-end lit des données déjà prêtes.
4. Remplacez WP-Cron par le cron système pour les tâches lourdes : WP-Cron ne se déclenche qu'à la visite du site et ne convient pas aux imports de longue durée.
5. Échappez toujours les données avant l'affichage (esc_html, esc_url, wp_kses_post) — une source externe ne peut pas être considérée comme fiable.
6. Journalisez les erreurs et vérifiez is_wp_error() à chaque étape : la source externe peut être indisponible, changer de format ou renvoyer des données corrompues.
7. Respectez les règles juridiques et éthiques : respectez le robots.txt, les limites de requêtes et les conditions d'utilisation de la source.

Conclusion

Le web scraping est un moyen puissant d'automatiser l'alimentation d'un site WordPress. Pour les besoins standards, des plugins comme WP All Import ou Feedzy suffisent souvent. Mais dès que la source ou la logique de traitement sort de l'ordinaire, un scraper PHP sur mesure offre incomparablement plus de contrôle et de flexibilité.

Nous avons examiné quatre scénarios pratiques — taux de change, actualités et RSS, prévisions météo et import des produits d'un fournisseur dans WooCommerce — et montré comment intégrer chacun d'eux dans l'écosystème WordPress à l'aide de l'API HTTP, des transients et du cron.

Pour approfondir la technologie d'extraction de données elle-même, commencez par l'article de base « Scraper en PHP ». Et si vous avez besoin d'un scraper prêt à l'emploi pour votre projet, nous nous en chargeons, de la mise en place de l'extraction d'articles de presse jusqu'à l'import complet du catalogue d'un fournisseur.