Apify et les proxys mobiles : guide étape par étape pour débuter avec le cloud

Introduction

Dans ce guide étape par étape, vous allez mettre en place un web scraping complet dans le cloud avec Apify en utilisant des proxys mobiles, créer un acteur en Node.js, exécuter une tâche de test pour collecter des fiches produits, et apprendre à gérer les limites en toute sécurité pour éviter les erreurs et les blocages. Le guide est destiné aux débutants, mais inclut des sections pour les utilisateurs avancés. À la fin, vous disposerez d'un acteur réutilisable, d'un schéma fonctionnel de proxy, de vérifications des résultats, de checklists, d'analyses des erreurs communes et de conseils d'optimisation. Si vous avez besoin d'une réponse rapide à une question pratique, allez immédiatement à la section FAQ, mais pour un résultat complet, suivez toutes les étapes.

Pour qui est ce guide : pour ceux qui souhaitent comprendre comment lancer un acteur Apify avec des proxys mobiles sans passer des semaines à examiner la documentation. Il sera utile aux marketeurs, analystes, chercheurs, propriétaires de projets web et développeurs débutants qui ont besoin d'une collecte de données fiable et répétable depuis le web.

Ce que vous devez savoir à l'avance : des notions de base en JavaScript seront un plus, mais pas indispensables. Nous expliquerons en détail où cliquer, quoi entrer et comment vérifier les résultats. Il est important de savoir se connecter à un service web, de copier les tokens d'accès et de travailler avec les mots de passe avec soin.

Combien de temps cela prendra : 2 à 3 heures pour un passage complet, y compris l'inscription, la configuration de l'acteur, l'intégration du proxy, le lancement de test et la vérification des résultats. Si vous avez déjà un compte Apify et accès à des proxys mobiles, cela peut se faire en 60 à 90 minutes.

Préparation préalable

Outils, programmes et accès nécessaires

• Un compte Apify avec accès pour lancer des acteurs.
• Node.js version LTS (18 ou supérieure) sur votre ordinateur local, si vous souhaitez éditer le code localement. Vous pouvez utiliser l'éditeur intégré d'Apify, mais il est plus pratique localement.
• Identifiants pour les proxys mobiles. Nous utilisons l'exemple du fournisseur mobileproxy.space, où vous pouvez obtenir un nom d'utilisateur, un mot de passe et une adresse de serveur proxy. Vous pouvez utiliser n'importe quel service similaire.
• Éditeur de texte : VS Code ou tout autre.
• Apify CLI (optionnel) pour le développement local et le téléchargement de l'acteur dans le cloud.

Exigences système

• Accès Internet stable.
• Windows, macOS ou Linux. Tout ordinateur moderne convient pour le travail local avec l'acteur.
• 200 à 500 Mo d'espace libre sur le disque pour les dépendances npm, si vous optez pour le développement local.

Ce qu'il faut télécharger et installer

1. Téléchargez Node.js depuis le site officiel, choisissez LTS. Après l'installation, vérifiez avec la commande dans le terminal : node -v et npm -v. Vous devez voir les versions sans erreur.
2. Installez Apify CLI (optionnel) avec la commande : npm i -g apify-cli. Après l'installation, vérifiez : apify --version.
3. Préparez vos identifiants pour les proxys mobiles : hôte, port, nom d'utilisateur et mot de passe. Si vous utilisez mobileproxy.space, vous recevrez une adresse au format host:port et une paire user:password.

⚠️ Attention : Ne publiez jamais vos identifiants de proxy dans des dépôts publics. Utilisez des variables d'environnement ou des secrets de plateforme.

Création de sauvegardes

Si vous éditez le code localement, gardez une sauvegarde du projet (par exemple, avec git). Sur Apify, la plateforme stocke elle-même les versions des acteurs, mais il est préférable d'avoir une sauvegarde locale du code.

Conseil : Si vous travaillez avec Apify pour la première fois, commencez directement dans le navigateur via l'éditeur de l'interface de la plateforme, et ajoutez le développement local plus tard. Cela accélérera le démarrage.

Concepts de base et qu'est-ce qu'Apify

Termes clés en termes simples

• Apify — une plateforme pour automatiser des tâches sur le web : scraping, crawling, intégrations. Permet d'exécuter du code (acteurs) dans le cloud, de stocker les résultats (Datasets) et de gérer les queues de liens.
• Acteur — application containerisée (généralement en Node.js ou Python) qui exécute votre tâche : ouvre des pages, collecte des données, enregistre les résultats.
• Tâche (Task) — configuration sauvegardée pour lancer un acteur avec une entrée pré-remplie. Pratique pour des redémarrages réguliers sans changer de code.
• Dataset — stockage des résultats du scraping sous forme de tableau. Peut être exporté en JSON, CSV, XLSX.
• Key-Value Store — stockage de fichiers et de configurations arbitraires (par exemple, paramètres d'entrée, rapports).
• Request Queue — queue de liens pour crawler, pour stocker et traiter les URL de manière systématique.
• ProxyConfiguration — configuration du proxy. Vous pouvez utiliser des proxys Apify ou externes, y compris mobiles.
• Proxys mobiles — proxys utilisant des réseaux de téléphonie mobile. Ils sont souvent perçus par les sites comme un véritable trafic mobile.

Principes de fonctionnement

Vous écrivez un acteur, lui passez des paramètres d'entrée et le lancez dans le cloud. L'acteur reçoit une liste de liens, les ouvre via le crawler choisi (par exemple, CheerioCrawler pour les pages HTML légères ou PlaywrightCrawler pour les sites plus complexes), collecte des données et les écrit dans un Dataset. Pour les requêtes réseau, l'acteur utilise des proxys selon la ProxyConfiguration. Lorsqu'il est nécessaire d'avoir une collecte stable avec un faible taux de fausses alertes de protection, des proxys mobiles sont utilisés. Ils permettent de répartir la charge et d'avoir l'air de naviguer comme un utilisateur mobile.

Ce qu'il est important de comprendre avant de commencer

• Respectez les règles des sites cibles et la législation en vigueur. Utilisez la collecte de données de manière éthique et légale.
• Même les proxys mobiles n'offrent pas une immunité contre les limitations. Il est crucial de contrôler le rythme des requêtes, les délais, les bons en-têtes HTTP et la qualité du code du crawler.
• Les limites de la plateforme Apify et votre plan tarifaire affectent le parallélisme, la mémoire et le temps d'exécution. Tout cela peut être configuré et contrôlé.

Conseil : Si la cible propose une API officielle, commencez par cela. C'est plus stable et éthique que de scraper du HTML.

Étape 1 : Pourquoi des proxys mobiles dans le scraping cloud

Objectif de l'étape

Comprendre dans quels cas les proxys mobiles offrent les meilleurs résultats et comment configurer les réglages pour minimiser les blocages et l'instabilité lors du travail dans le cloud.

Instruction étape par étape

1. Détaillez l'objectif de la collecte de données : liste de produits, prix, avis, horaires, actualités. Notez les types de pages précis et leurs URL approximatives.
2. Évaluez la complexité du site : la page s'ouvre-t-elle sans JavaScript, à quelle vitesse se charge-t-elle, y a-t-il une charge dynamique. Si le site est simple, un CheerioCrawler suffira ; s'il est complexe, utilisez PlaywrightCrawler.
3. Décidez si une session mobile est nécessaire : si le site est clairement orienté vers les utilisateurs mobiles, montre des versions de pages différentes pour mobiles et clients PC, des proxys mobiles aideront à paraître naturel.
4. Choisissez un fournisseur de proxys mobiles. Prenez mobileproxy.space comme exemple. Assurez-vous d'avoir un hôte stable, un port, un nom d'utilisateur et un mot de passe. Notez-les séparément.
5. Planifiez la fréquence des requêtes. Commencez par 1 à 2 onglets simultanés et 1 à 3 requêtes par seconde. Augmentez progressivement si nécessaire, en surveillant les erreurs et les réponses du site.
6. Décidez si vous utiliserez une rotation IP. Pour les proxys mobiles, la rotation peut se faire sur demande ou par minuteur proposé par votre fournisseur. Vérifiez la politique et les commandes de rotation auprès de votre fournisseur.

Éléments clés

Les proxys mobiles sont adaptés pour réduire les risques de fausses alertes de protection ou reproduire le comportement d'un client mobile. Ne les utilisez pas pour des actions interdites par le site ou par la loi. Configurez correctement les en-têtes User-Agent et les délais.

⚠️ Attention : Ne tentez pas de contourner les limitations techniques des sites. Si une page est fermée par authentification ou conditions d'utilisation, agissez conformément aux règles de la ressource.

Résultat attendu

Vous comprenez pourquoi des proxys mobiles sont appliqués, avez choisi un fournisseur et êtes prêts à configurer dans l'acteur. Vous avez vos identifiants de proxy et un plan de fréquence des requêtes.

Problèmes potentiels et solutions

• Pas clair si une version mobile est nécessaire. Solution : ouvrez le site avec un User-Agent mobile dans l'outil de développement et comparez le balisage. Si la différence est significative, une session mobile est pertinente.
• Vous doutez de la fiabilité du fournisseur. Solution : testez la connexion via curl avec votre proxy, vérifiez la stabilité pendant 10 à 15 minutes.

✅ Vérification : Vous avez les paramètres précis du proxy (hôte, port, nom d'utilisateur, mot de passe) et avez noté la fréquence des requêtes désirée.

Étape 2 : Inscription à Apify et préparation de l'espace de travail

Objectif de l'étape

Créer ou confirmer un compte Apify, se connecter à la console, installer si nécessaire Apify CLI et se préparer à créer un acteur.

Instruction étape par étape

1. Inscrivez-vous sur Apify. Saisissez votre e-mail, créez un mot de passe, confirmez l'e-mail. Une fois connecté, la console s'ouvrira avec les sections Actors, Tasks, Storage.
2. Allez dans votre profil et trouvez votre token API personnel. Copiez-le dans un endroit sécurisé, vous en aurez besoin pour CLI et pour les intégrations.
3. Si vous utilisez CLI : installez apify-cli avec la commande npm i -g apify-cli. Ensuite, exécutez apify login et collez votre token. Après une connexion réussie, vous verrez une confirmation dans le terminal.
4. Créez un dossier de projet localement si vous optez pour le développement local. Exécutez apify create et choisissez un modèle en Node.js avec Crawlee. Une structure de projet sera créée avec package.json et src/main.js.
5. Si vous travaillez seulement dans le navigateur : cliquez sur New dans la section Actors et choisissez le modèle Node.js + Crawlee. La plateforme créera un acteur vide et ouvrira l'éditeur en ligne.

Éléments clés

La sécurité du token est cruciale. Ne collez pas le token dans le code. Gardez-le dans un gestionnaire de mots de passe. Dans CLI, il est enregistré localement et n'est pas ajouté au dépôt, à moins que vous ne l'ajoutiez manuellement.

Conseil : Nommez l'acteur de manière significative, par exemple mobile-crawler-products. Cela simplifiera la navigation et l'automatisation.

Résultat attendu

Vous êtes connecté à la console Apify, si désiré vous avez configuré CLI, créé un acteur vide et voyez le fichier main.js dans l'éditeur (ou localement dans le dossier src).

Problèmes potentiels et solutions

• CLI ne voit pas le token. Solution : exécutez apify logout et à nouveau apify login. Vérifiez que vous saisissez le token actuel de votre profil.
• Erreurs d'installation des dépendances npm. Solution : mettez à jour Node.js vers LTS, nettoyez le cache npm avec la commande npm cache clean --force et réessayez l'installation.

✅ Vérification : Vous avez un acteur créé avec accès à l'édition du code et la structure de base du projet en place.

Étape 3 : Création de l'acteur et chargement du modèle

Objectif de l'étape

Remplir l'acteur avec du code de démarrage sur Crawlee pour pouvoir immédiatement lancer le crawler et s'assurer de sa fonctionnalité de base sans proxy.

Instruction étape par étape

1. Ouvrez le fichier main.js. S'il n'existe pas, créez src/main.js. Assurez-vous que package.json contient des dépendances crawlee et apify.
2. Collez le code de base du crawler. Exemple pour CheerioCrawler : import { CheerioCrawler, Dataset } from "crawlee"; export const main = async () => { const startUrls = ["https://example.com/"]; const crawler = new CheerioCrawler({ requestHandler: async ({ request, $, log }) => { const title = $("title").text(); await Dataset.pushData({ url: request.loadedUrl, title }); log.info(`Saved: ${request.loadedUrl}`); }, maxConcurrency: 2, requestHandlerTimeoutSecs: 60, }); for (const url of startUrls) await crawler.addRequests([url]); await crawler.run(); };
3. Enregistrez le fichier. Si dans le navigateur, cliquez sur le bouton Save. Si localement, enregistrez les modifications et exécutez npm install pour installer les bibliothèques (si elles ne l'ont pas été déjà).
4. Essayez de lancer sans proxy : exécutez l'acteur avec les entrées par défaut. Dans Dataset, vous devriez voir au moins un objet avec le champ title.

Éléments clés

Un MVP minimal de l'acteur est nécessaire pour vérifier le pipeline : lancement, journalisation, sauvegarde des résultats. Avant d'ajouter des proxys, assurez-vous que le code fonctionne sur une page simple.

Conseil : Commencez avec une ou deux URL de départ. Cela accélérera les tests et facilitera la recherche de problèmes.

Résultat attendu

L'acteur s'exécute avec succès et sauvegarde les résultats dans le Dataset. Vous voyez des logs indiquant que les données ont été sauvegardées, et aucune erreur de type DNS ou de délai d'attente réseau.

Problèmes potentiels et solutions

• Erreur d'importation de paquets. Solution : vérifiez les versions dans package.json. Si besoin, exécutez npm i crawlee apify.
• Aucun données dans le Dataset. Solution : vérifiez le sélecteur $("title").text() ou remplacez-le par un autre sélecteur simple, comme $("h1").first().text().

✅ Vérification : Dans le Dataset, au moins un objet avec les champs url et title est présent. Les logs montrent une fin réussie sans exceptions.

Étape 4 : Configuration du proxy dans l'acteur

Objectif de l'étape

Connecter des proxys mobiles à l'acteur Apify pour que tout le trafic réseau du crawler passe par le serveur proxy spécifié et s'assurer de la stabilité de la connexion.

Instruction étape par étape

1. Préparez la chaîne du proxy. Format pour un proxy HTTP externe : http://USERNAME:PASSWORD@HOST:PORT. Exemple : http://user123:pass456@proxy.mobileproxy.space:12345. Pour mobileproxy.space, utilisez les identifiants de votre espace client.
2. Ajoutez ProxyConfiguration au code. Pour CheerioCrawler : import { CheerioCrawler, Dataset, ProxyConfiguration } from "crawlee"; export const main = async () => { const proxy = new ProxyConfiguration({ proxyUrls: ["http://USERNAME:PASSWORD@HOST:PORT"] }); const crawler = new CheerioCrawler({ proxyConfiguration: proxy, requestHandler: async ({ request, $, log }) => { const title = $("title").text(); await Dataset.pushData({ url: request.loadedUrl, title }); log.info(`Saved: ${request.loadedUrl}`); }, maxConcurrency: 2, requestHandlerTimeoutSecs: 60, }); await crawler.addRequests(["https://httpbin.org/ip"]); await crawler.run(); };
3. Enregistrez les modifications et lancez l'acteur. Si tout est correct, dans Dataset, vous verrez l'adresse IP qui appartient à votre proxy mobile (pour httpbin.org/ip, cela sera un JSON avec origin ou l'IP du proxy).
4. Si vous utilisez PlaywrightCrawler, ajoutez la même ProxyConfiguration dans les paramètres du constructeur : import { PlaywrightCrawler, Dataset, ProxyConfiguration } from "crawlee"; const proxy = new ProxyConfiguration({ proxyUrls: ["http://USERNAME:PASSWORD@HOST:PORT"] }); const crawler = new PlaywrightCrawler({ proxyConfiguration: proxy, launchContext: { launchOptions: { headless: true } }, requestHandler: async ({ page, request, log }) => { const title = await page.title(); await Dataset.pushData({ url: request.loadedUrl, title }); log.info(`Saved: ${request.loadedUrl}`); } });
5. Si nécessaire, déplacez la chaîne du proxy dans une variable d'environnement et lisez-la avec process.env, pour ne pas stocker le mot de passe dans le code. Sur la plateforme Apify, utilisez la section Secrets et ENV Vars dans les paramètres de l'acteur. Exemple : const proxyUrl = process.env.MOBILE_PROXY_URL;

Éléments clés

Ne mélangez pas simultanément le proxy Apify et la configuration de proxy mobile externe. Pour un seul lancement, utilisez une source de proxy claire. La configuration via proxyUrls remplace entièrement l'utilisation des proxys Apify.

Conseil : Testez d'abord le proxy sur des pages simples comme https://httpbin.org/ip ou des services similaires d'affichage d'IP. Cela vous permettra de voir immédiatement que le trafic passe par l'adresse correcte.

⚠️ Attention : Si votre fournisseur de proxys mobiles prend en charge la rotation d'IP via une URL spéciale ou une commande, utilisez cela uniquement dans le cadre de ses règles. Ne changez pas d'IP trop souvent sans nécessité : cela pourrait éveiller les soupçons du site cible.

Résultat attendu

Le crawler est correctement connecté au proxy mobile. Lors du contrôle de l'IP (par une page de test), vous voyez l'adresse du proxy, les logs sont stables, les requêtes ne tombent pas en délais d'attente.

Problèmes potentiels et solutions

• 401 ou 407 dans les logs. Raisons : nom d'utilisateur ou mot de passe erronés. Solution : vérifiez les identifiants du fournisseur.
• ECONNRESET ou ETIMEDOUT. Raisons : instabilité du canal ou blocage de domaine. Solution : réduisez le parallélisme, relancez après une pause, vérifiez l'état du proxy auprès du fournisseur.

✅ Vérification : Le Dataset contient le résultat d'une requête sur la page affichant l'IP, et l'adresse du proxy mobile y est visible.

Étape 5 : Exemple de tâche : collecte de données à partir de fiches produits

Objectif de l'étape

Collecter des données depuis de vraies fiches produits, en utilisant des proxys mobiles et des réglages stables pour le crawler, et sauvegarder les résultats dans le Dataset.

Instruction étape par étape

1. Définissez la liste cible d'URL des fiches ou des catégories où vous pouvez collecter des données ouvertes de manière sûre et légale. Notez 3 à 5 liens pour le test.
2. Choisissez un crawler. Si la page est statique, utilisez CheerioCrawler. Si les données se chargent dynamiquement, choisissez PlaywrightCrawler.
3. Ajoutez les sélecteurs principaux pour extraire les données. Par exemple : nom du produit, prix, devise, note, disponibilité. Dans Cheerio, ce seront des sélecteurs similaires à jQuery ; dans Playwright — page.locator.
4. Exemple pour CheerioCrawler : import { CheerioCrawler, Dataset, ProxyConfiguration, log } from "crawlee"; export const main = async () => { log.setLevel(log.LEVELS.INFO); const proxy = new ProxyConfiguration({ proxyUrls: [process.env.MOBILE_PROXY_URL] }); const startUrls = ["https://example.com/product/1", "https://example.com/product/2"]; const crawler = new CheerioCrawler({ proxyConfiguration: proxy, maxConcurrency: 2, requestHandlerTimeoutSecs: 90, requestHandler: async ({ request, $, log }) => { const title = $("h1.product-title").text().trim(); const priceText = $("span.price").text().trim(); const availability = $("div.stock").text().trim(); const currency = priceText.replace(/[0-9.,\s]/g, ""); const price = parseFloat(priceText.replace(/[^0-9.,]/g, "").replace(",", ".")) || null; await Dataset.pushData({ url: request.loadedUrl, title, price, currency, availability }); log.info(`Saved: ${title || "no title"}`); }, failedRequestHandler: async ({ request, log }) => { log.warning(`Failed ${request.url}`); } }); await crawler.addRequests(startUrls); await crawler.run(); };
5. Exemple pour PlaywrightCrawler : import { PlaywrightCrawler, Dataset, ProxyConfiguration } from "crawlee"; export const main = async () => { const proxy = new ProxyConfiguration({ proxyUrls: [process.env.MOBILE_PROXY_URL] }); const startUrls = ["https://example.com/product/1"]; const crawler = new PlaywrightCrawler({ proxyConfiguration: proxy, requestHandlerTimeoutSecs: 120, launchContext: { launchOptions: { headless: true } }, requestHandler: async ({ page, request, log }) => { await page.waitForLoadState("domcontentloaded"); const title = await page.title(); const price = await page.locator("span.price").first().textContent().catch(() => null); await Dataset.pushData({ url: request.loadedUrl, title, price }); log.info(`Saved: ${request.loadedUrl}`); } }); await crawler.addRequests(startUrls); await crawler.run(); };
6. Enregistrez MOBILE_PROXY_URL dans les variables d'environnement de l'acteur sur la plateforme Apify (section Settings → Environment variables). Valeur : votre chaîne proxy sous la forme http://user:pass@host:port.
7. Lancez l'acteur. Dans les logs, surveillez le statut de la requête, le temps de réponse et le nombre d'enregistrements correctement sauvegardés.

Éléments clés

La structure des données dans le Dataset doit être prévisible : définissez les mêmes champs pour toutes les fiches, sinon l'export vers des tableaux sera difficile. Contrôlez les délais : pour des pages dynamiques, augmentez requestHandlerTimeoutSecs et ajoutez des attentes pour charger des sélecteurs clés.

Conseil : Pour une charge fluide, définissez des délais min/max entre les requêtes avec les paramètres d'un pool autoscalé ou ajoutez manuellement des pauses dans le gestionnaire.

Résultat attendu

Dans le Dataset, chaque fiche produit contient un enregistrement avec des champs clés. Les logs sont stables, il n'y a pas d'erreurs d'autorisation de proxy, et le temps de réponse moyen est acceptável pour votre cas.

Problèmes potentiels et solutions

• Sélecteurs incorrects. Raisons : mise en page adaptative ou structure de page différente. Solution : vérifiez les versions mobile et desktop, utilisez des sélecteurs plus robustes (data-attributs, id uniques).
• Données vides dans certains champs. Raisons : valeurs chargé dynamiquement. Solution : ajoutez une attente explicite pour les éléments nécessaires ou utilisez Playwright à la place de Cheerio.

✅ Vérification : Dans le Dataset, les enregistrements contiennent des fields url, title, price ou équivalents. Le pourcentage moyen d'erreurs est faible et inférieur à 5–10% dans l'échantillon test.

Étape 6 : Limites et optimisation

Objectif de l'étape

Configurer le parallélisme, les délais, les tentatives de répétition, la rotation et le stockage pour utiliser efficacement les limites d'Apify et améliorer la stabilité de la collecte.

Instruction étape par étape

1. Limitez le parallélisme. Dans les paramètres du crawler, définissez maxConcurrency de 1 à 3 au début. Augmentez progressivement. Plus le parallélisme est élevé, plus la charge sur le proxy et le site est importante.
2. Configurez les tentatives de répétition. Dans Crawlee, il existe retryCount et retryTimeoutMillis. Définissez retryCount = 1–2 pour ne pas interroger indéfiniment des pages problématiques.
3. Gérez le temps d'exécution. Augmentez requestHandlerTimeoutSecs à 90–120 pour les pages lourdes. Cela réduira les fausses alertes de délai d'attente lors des réponses lentes sur le réseau mobile.
4. Ajoutez des délais aléatoires. Insérez de courtes pauses de 300 à 1500 ms entre les requêtes. Cela paraît plus naturel et réduit le risque de limitations.
5. Planifiez la rotation de proxys auprès du fournisseur dans des limites raisonnables. Si mobileproxy.space permet d'obtenir une nouvelle IP sur minuteur, choisissez un intervalle qui ne compromet pas la stabilité des sessions.
6. Surveillez les limites d'Apify : mémoire, CPU, temps. Dans les paramètres de lancement, définissez Memory (par exemple, 1024–2048 Mo pour Playwright) et Max run time (par exemple, 30–60 minutes pour des batchs).
7. Conservez uniquement les champs nécessaires. Moins de données redondantes dans le Dataset entraîne une charge de stockage réduite et un export plus rapide. Supprimez les fragments HTML non nécessaires.
8. Activez la journalisation au niveau INFO, et sélectivement au DEBUG lors du débogage. Un volume excessif de logs peut gêner la lecture et n'est pas nécessaire en mode stable.

Éléments clés

Économiser les limites peut être réalisé avec quelques règles simples : faible parallélisme de départ, courtes tentatives de répetition, sélecteurs précis et minimisation des accès inutiles à la page. Surveillance via logs et monitoring aide à ajuster les réglages.

Conseil : Enregistrez les URL réussies dans le Key-Value Store ou un stockage externe. Cela facilitera la reprise en cas d'échec et évitera de retraiter les pages déjà collectées.

Résultat attendu

L'acteur fonctionne correctement, ne consomme pas de ressources inutiles, et les erreurs se produisent rarement et de manière prévisible. Les paramètres de délais et de parallélisme sont adaptés à la vitesse de votre proxy mobile et à la complexité du site.

Problèmes potentiels et solutions

• Augmenter les délais n'aide pas. Raisons : surcharge de la page ou problèmes auprès du fournisseur. Solution : réduisez temporairement le parallélisme à 1 et vérifiez la stabilité de la connexion.
• Vitesse trop lente. Raisons : goulet d'étranglement dans le réseau proxy ou site lourd. Solution : augmentez les délais, mais envisagez également de diviser les tâches en batchs plus petits.

✅ Vérification : Le temps moyen par page est stable, et le pourcentage d'erreurs n’augmente pas avec le volume, les limites de mémoire et de temps ne sont pas dépassées.

Vérification du résultat

Checklist : ce qui doit fonctionner

• L'acteur se lance sans erreurs et termine correctement.
• Les proxys mobiles sont connectés et l'IP dans les requêtes de test correspond au proxy.
• Le Dataset contient les champs et valeurs attendus.
• Les logs sont informatifs, mais pas surchargés.
• Lors d'un nouveau lancement, il n'y a pas de doublons (ou ils sont contrôlés).

Comment tester

1. Lancez l'acteur sur 2 à 3 URL de test avec proxy activé et vérifiez l'IP via une page indicatrice.
2. Comparez les chiffres : combien de requêtes ont été ajoutées et combien de résultats vous avez obtenus. Ils devraient coïncider ou différer dans une marge d'erreur raisonnable.
3. Exportez le Dataset au format CSV et assurez-vous que les données sont propres : sans null là où vous attendez des valeurs.

Indicateurs de réussite

• Le pourcentage de requêtes échouées est inférieur à 5–10% lors du test.
• Le temps moyen de traitement des pages est stable et prévisible.
• Aucune anomalie dans les délais d'attente et les erreurs d'autorisation de proxy.

Conseil : Enregistrez un ensemble de contrôle des URL et répétez le test avant chaque changement de code important. Cela vous aidera à détecter rapidement les régressions.

Erreurs communes et solutions

• Problème : 407 Proxy Authentication Required. Raisons : identifiants de proxy erronés. Solution : vérifiez le nom d'utilisateur et le mot de passe, mettez à jour les variables d'environnement et relancez l'acteur.
• Problème : ECONNRESET et ETIMEDOUT dans les logs. Raisons : instabilité du réseau ou surcharge. Solution : réduisez maxConcurrency, augmentez les délais et faites des pauses entre les requêtes.
• Problème : champs vides dans le Dataset. Raisons : sélecteurs incorrects ou chargement dynamique. Solution : utilisez PlaywrightCrawler, ajoutez des attentes, revoyez les sélecteurs.
• Problème : limite de mémoire atteinte. Raisons : trop d'onglets parallèles ou stockage de données superflues. Solution : réduisez le parallélisme, limitez le volume des données, augmentez Memory dans les paramètres de lancement.
• Problème : collecte trop lente. Raisons : pages lourdes et réseau mobile. Solution : concentrez-vous sur la priorité des données, divisez la tâche en batchs et optimisez les sélecteurs en désactivant les navigations inutiles.
• Problème : doublons dans les résultats. Raisons : redémarrage avec les mêmes URL sans filtrage. Solution : gardez une liste des liens traités dans la Request Queue avec vérification des doublons avant la sauvegarde.
• Problème : un site sensible réagit à des requêtes fréquentes. Raisons : rythme trop agressif. Solution : réduisez la vitesse, ajoutez un jitter aux délais, utilisez des en-têtes corrects et un User-Agent actuel.

Conseil : Lors du débogage, activez temporairement des logs détaillés pour un ou deux URL et analysez chaque étape. C'est plus rapide que de gérer de longs batchs.

Fonctionnalités avancées

Configurations avancées

• Secrets et configurations. Conservez MOBILE_PROXY_URL et autres clés dans la section Secrets. Dans le code, lisez-les via process.env.
• Changement de User-Agent. Pour simuler un client mobile, définissez un User-Agent mobile et une largeur de viewport appropriée dans Playwright. Faites-le de manière modérée et uniquement si nécessaire pour un affichage correct de la page.
• Planificateur de tâches. Créez une Task et attribuez un calendrier de lancements (journalier, horaire). Surveillez les limites et le volume des résultats.

Optimisation

• Mise en cache. Si les pages changent rarement, ajoutez un cache pour les requêtes et les visites répétées, afin de ne pas gaspiller les proxys et les limites.
• Queues et priorités. Travaillez via Request Queue, en attribuant une priorité aux liens importants et en ignorant les secondaires.
• Division en microservices. Divisez une tâche complexe en plusieurs acteurs : collecte de liens, traitement des fiches, validation et exportation.

Quoi d'autre réaliser

• Intégrations par API. Connectez l'envoi de résultats à votre CRM ou système analytique après chaque lancement via Webhook.
• Validation des données. Avant l'export, vérifiez les schémas : pour que toutes les valeurs correspondent aux types et aux plages attendus.
• Liens internes dans le document. Revenez à la section Limites et optimisation si besoin en matière de réglage des performances.

Conseil : Utilisez le mode aperçu et des batchs petits pour un passage initial dans le calendrier, puis augmentez progressivement.

FAQ

• Comment savoir si un proxy est vraiment mobile ? Vérifiez l'ASN et le type de réseau par IP via des bases de données tierces et comparez avec les opérateurs mobiles. Les proxys mobiles ont souvent un pool d'adresses caractéristique avec des changements dynamiques.
• Peut-on utiliser plusieurs proxys mobiles à la fois ? Oui, spécifiez plusieurs proxyUrls. Crawlee choisira automatiquement un parmi la liste. Attention aux limites de chaque proxy.
• Que faire si le site affiche un captcha ? Réduisez la fréquence, ajoutez des retards, vérifiez les en-têtes et envisagez d'utiliser l'API officielle de la ressource. Évitez les actions qui enfreignent les règles du site.
• Comment stocker les mots de passe des proxys en toute sécurité ? Utilisez des variables d'environnement et des Secrets sur la plateforme Apify. Ne commitez pas les mots de passe dans git.
• Faut-il changer le User-Agent pour un mobile ? Seulement si le site renvoie différentes versions de la page. Sinon, un comportement stable et des délais corrects suffisent.
• Pourquoi CheerioCrawler est-il plus rapide ? Il ne rend pas la page, mais analyse le HTML. Pour des pages dynamiques, utilisez PlaywrightCrawler, bien qu'il soit plus lent.
• Comment exporter les résultats ? Dans l'interface du Dataset, choisissez d'exporter en CSV, JSON, XLSX. Ou utilisez l'API Datasets si vous souhaitez automatiser l'export.
• Peut-on combiner Apify Proxy et proxys mobiles ? Pour un même lancement, il est préférable de n'utiliser qu'une option. Si vous avez besoin de différentes sources, divisez les tâches par acteur ou par configurations de lancement.
• Combien de requêtes par seconde est sûr ? Commencez par 1 à 3 par seconde et suivez les métriques. Pour des sites sensibles, réduisez à 0.2–0.5 avec pauses.
• Faut-il inclure headful dans Playwright ? Seulement pour le débogage. En production, utilisez headless pour économiser des ressources.

Conclusion

Vous avez configuré un acteur Apify fonctionnel avec des proxys mobiles, compris les concepts clés et les principes, collecté des données de test à partir de fiches produits et optimisé les limites. Désormais, vous gérez avec confiance le parallélisme, le temps d'attente et le stockage des résultats, tout en sachant comment sécuriser les secrets et mots de passe. Vous pouvez maintenant développer le projet : ajouter de nouveaux types de pages, construire un pipeline avec plusieurs acteurs, connecter un planificateur et des exports automatiques. Si vous avez des questions spécifiques, retournez à la section FAQ ou à Limites et optimisation. Rappelez-vous que les proxys mobiles sont un outil pour augmenter la stabilité et la naturalité du trafic, et non un moyen de contourner les limitations. Travaillez de manière éthique, respectez les règles des sites et commencez toujours par des petites étapes, en vérifiant chaque changement.