Comment scraper les données Just Eatrestaurants, menus et notes

Just Eat est l'une des plus grandes places de marché de livraison de repas en ligne en Europe, connectant des millions de convives aux restaurants locaux. Chaque page de zone est un catalogue public et structuré de qui livre à proximité : le nom du restaurant, les cuisines proposées, sa note étoilée, les détails de livraison, et un lien direct vers son menu. Ces données constituent un signal propre pour quiconque étudie les marchés alimentaires locaux, suit les cuisines dominantes dans un code postal, compare les prix des menus ou construit un outil de découverte de restaurants.

Ce guide vous explique comment scraper des données Just Eat avec Python. Vous construisez un petit scraper fonctionnel qui récupère une page de zone Just Eat via la Crawling API, analyse un enregistrement propre pour chaque restaurant, suit le lien d'un restaurant pour extraire ses articles de menu, gère la pagination par défilement du site et exporte les résultats en JSON et CSV. L'ensemble du tutoriel se limite aux données d'annonces publiques : les noms, cuisines, notes, liens et prix de menus que chacun peut voir sur une page de zone ou de menu sans se connecter.

Ce que vous allez construire

Un script Python qui prend une URL de zone Just Eat, récupère la page rendue via la Crawling API et extrait un enregistrement structuré par restaurant. Nous utilisons la page de zone London Bridge comme exemple fil rouge, la même zone que l'ancien tutoriel utilisait, et extrayons ces champs de chaque carte de restaurant :

• Nom le nom du restaurant affiché sur la carte d'annonce.
• Cuisine les étiquettes de cuisine, par exemple "Pizza, Italien".
• Note la note étoilée et le nombre d'avis, par exemple "4.5(26)".
• Lien l'URL absolue vers la page de menu du restaurant.
• Articles du menu par plat, la catégorie, le nom, le prix et la description depuis la page de menu du restaurant.

Pourquoi une simple requête échoue sur Just Eat

Si vous pointez un client HTTP basique vers une URL de zone Just Eat, vous obtenez rarement la liste de restaurants que vous cherchez. Deux obstacles se dressent face à vous. D'abord, Just Eat rend ses annonces côté client : le serveur envoie une coquille légère, et les cartes se remplissent à mesure que le JavaScript de la page s'exécute et que vous faites défiler, donc le HTML initial est souvent une grille vide. Ensuite, le site signale rapidement le trafic automatisé. Les adresses IP de datacenter et les modèles de requêtes qui ne ressemblent pas à un vrai navigateur sont accueillis par une page de challenge, un CAPTCHA ou un blocage pur et simple.

Un scraper Just Eat fonctionnel nécessite donc deux choses dans une seule requête : un navigateur qui rende la page et une adresse IP que le site perçoit comme un visiteur réel. Vous pouvez assembler cela vous-même avec un navigateur headless et un pool de proxies résidentiels rotatifs, mais maintenir cet ensemble en bon état représente l'essentiel du travail. La Crawling API réunit les deux en un seul appel : vous lui envoyez l'URL de zone, elle rend la page derrière une adresse IP résidentielle de confiance, gère la rotation et la résolution des CAPTCHA, et vous retourne le HTML complet prêt à être analysé.

Prérequis

Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si vous débutez dans le langage, la documentation officielle Python ou n'importe quel cours pour débutants couvre le niveau que ce tutoriel suppose.

Python 3.8 ou version ultérieure. Vérifiez votre version avec python --version (ou python3 --version). Si vous ne l'avez pas, installez-le depuis python.org et assurez-vous que Python est dans le PATH de votre système.

Un compte Crawlbase et un token. Inscrivez-vous pour un compte gratuit, ouvrez votre tableau de bord et copiez votre token. Crawlbase émet deux tokens : un token normal pour les sites statiques et un token JavaScript pour les sites rendus en JS comme Just Eat. Le niveau gratuit inclut jusqu'à 20 000 requêtes sans carte bancaire. Traitez le token comme un mot de passe et gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour isoler les dépendances du projet, puis installez les deux bibliothèques dont le scraper a besoin. crawlbase est le client officiel de la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire chaque champ des cartes de restaurant par sélecteur CSS.

python --version

python -m venv just_eat_env
source just_eat_env/bin/activate

pip install crawlbase beautifulsoup4

Sur Windows, activez l'environnement avec just_eat_env\Scripts\activate au lieu de la ligne source. Avec les deux bibliothèques installées, créez le fichier de script que le reste du guide va construire :

touch just_eat_scraper.py

Inspecter la page de zone pour trouver les sélecteurs

Pour scraper des données, vous devez d'abord comprendre comment la page de zone Just Eat est structurée. Ouvrez une page de zone dans votre navigateur, par exemple la page https://www.just-eat.co.uk/area/ec4r3tn pour la zone London Bridge, cliquez droit sur une carte de restaurant et choisissez Inspecter. Just Eat marque ses éléments clés avec des attributs data-qa stables, bien plus durables que ses noms de classes utilitaires générés. Ce sont les éléments que vous ciblez :

• Carte de restaurant : un <div> avec data-qa="restaurant-card" enveloppe chaque annonce.
• Nom du restaurant : un <div> avec data-qa="restaurant-info-name".
• Type de cuisine : un <div> avec data-qa="restaurant-cuisine".
• Note : un <div> avec data-qa="restaurant-ratings".
• Lien du restaurant : le href sur la balise <a> à l'intérieur de la carte, qui est relatif, à préfixer donc avec https://www.just-eat.co.uk.

Étape 1 : Récupérer la page de zone rendue

Commencez par obtenir la page complète. Importez la classe CrawlingAPI, initialisez-la avec votre token, définissez l'URL de zone et demandez-la. Le contenu Just Eat se charge de manière asynchrone, passez donc ajax_wait pour attendre le contenu dynamique et page_wait pour maintenir un délai de quelques secondes après le chargement. Vérifier le code de statut avant d'analyser permet de rendre les échecs visibles plutôt que silencieux.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def fetch_listings(url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Status: {response['status_code']}")
    return None

if __name__ == "__main__":
    area_url = "https://www.just-eat.co.uk/area/ec4r3tn"
    html = fetch_listings(area_url)
    print(html[:500] if html else "No HTML returned")

Les deux options d'attente sont importantes pour une grille qui se remplit après le chargement. ajax_wait indique à l'API d'attendre que le contenu asynchrone soit terminé, et page_wait maintient un délai fixe en millisecondes pour que les cartes à rendu tardif apparaissent avant la capture de la page. Exécutez le script et vous devriez voir le vrai balisage des annonces, pas une coquille vide ou une page de challenge. Cela confirme que le rendu fonctionne avant d'écrire le moindre sélecteur.

Étape 2 : Analyser les cartes de restaurant avec BeautifulSoup

Avec le HTML rendu en main, chargez-le dans BeautifulSoup, trouvez chaque carte de restaurant et extrayez chaque champ par son sélecteur data-qa. Chaque carte porte le nom, la cuisine et la note, plus une ancre dont le href relatif est préfixé avec l'URL de base du site. Un petit helper text_of retourne une chaîne vide quand un champ est manquant au lieu de lever une erreur sur un appel .text contre rien.

from bs4 import BeautifulSoup

BASE = "https://www.just-eat.co.uk"

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else ""

def parse_restaurants(html):
    soup = BeautifulSoup(html, "html.parser")
    restaurants = []
    cards = soup.select('div[data-qa="restaurant-card"]')
    for card in cards:
        try:
            anchor = card.select_one("a[href]")
            link = BASE + anchor["href"] if anchor else ""
            restaurants.append({
                "name": text_of(card, 'div[data-qa="restaurant-info-name"]'),
                "cuisine": text_of(card, 'div[data-qa="restaurant-cuisine"]'),
                "rating": text_of(card, 'div[data-qa="restaurant-ratings"]'),
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return restaurants

Le sélecteur data-qa="restaurant-card" trouve les conteneurs d'annonces, et select_one lit chaque champ à l'intérieur d'une carte. Le champ de note arrive sous forme de chaîne combinée comme "4.5(26)", le score étoilé suivi du nombre d'avis entre parenthèses ; gardez-le brut ici et divisez-le en aval si vous avez besoin des deux valeurs séparément. Le lien est relatif sur la page, donc le préfixer avec BASE vous donne une URL absolue que vous pouvez suivre directement vers le menu. Encapsuler chaque carte dans un try/except signifie qu'une annonce malformée ne fait pas planter toute l'exécution.

Étape 3 : Gérer la pagination par défilement

Just Eat ne pagine pas avec des pages numérotées. Il utilise le défilement infini : plus de restaurants se chargent à mesure que vous faites défiler vers le bas. La Crawling API peut piloter ce défilement pour vous, sans que vous ayez à le gérer manuellement. Remplacez les options d'attente par scroll et un scroll_interval, qui indique à l'API combien de secondes continuer à faire défiler et à charger avant de capturer la page. Vous n'avez pas besoin de page_wait en plus ; l'intervalle de défilement couvre l'attente.

def fetch_listings(url):
    options = {"scroll": "true", "scroll_interval": "20"}
    response = api.get(url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Status: {response['status_code']}")
    return None

Ici, scroll_interval est défini à 20, donc l'API fait défiler pendant 20 secondes avant de capturer, suffisamment long pour charger la plupart des restaurants dans une zone animée. Augmentez pour les zones plus denses et diminuez pour les zones moins actives ; des défilements plus longs coûtent plus de temps par requête, donc calibrez en fonction de la page. Avec cela en place, parse_restaurants voit la grille complète et non plus seulement le premier écran.

Étape 4 : Assembler le script d'annonces et exporter en JSON et CSV

Maintenant, reliez la récupération et l'analyse dans un script exécutable unique, puis écrivez les enregistrements en JSON et en CSV pour pouvoir les charger dans un notebook ou un tableur. Une liste FIELDS partagée maintient l'ordre des colonnes CSV en phase avec les clés du dictionnaire pour que les deux exports ne divergent jamais.

import csv
import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.just-eat.co.uk"
FIELDS = ["name", "cuisine", "rating", "link"]

def fetch_listings(url):
    options = {"scroll": "true", "scroll_interval": "20"}
    response = api.get(url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the page. Status: {response['status_code']}")
    return None

def text_of(card, selector):
    el = card.select_one(selector)
    return el.get_text(strip=True) if el else ""

def parse_restaurants(html):
    soup = BeautifulSoup(html, "html.parser")
    restaurants = []
    cards = soup.select('div[data-qa="restaurant-card"]')
    for card in cards:
        try:
            anchor = card.select_one("a[href]")
            link = BASE + anchor["href"] if anchor else ""
            restaurants.append({
                "name": text_of(card, 'div[data-qa="restaurant-info-name"]'),
                "cuisine": text_of(card, 'div[data-qa="restaurant-cuisine"]'),
                "rating": text_of(card, 'div[data-qa="restaurant-ratings"]'),
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return restaurants

def export(rows, name="just_eat_restaurants"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=4, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} restaurants to {name}.json and {name}.csv")

def main():
    url = "https://www.just-eat.co.uk/area/ec4r3tn"
    html = fetch_listings(url)
    if not html:
        return
    rows = parse_restaurants(html)
    export(rows)

if __name__ == "__main__":
    main()

Exécutez le script complet avec python just_eat_scraper.py. Il récupère la page de zone rendue et défilée, analyse une ligne par restaurant, et écrit à la fois just_eat_restaurants.json et just_eat_restaurants.csv. Le champ link sur chaque ligne est l'URL exacte que vous passez au scraper de menu dans la section suivante.

À quoi ressemble le résultat des annonces

Vous obtenez une liste propre d'enregistrements de restaurants, dans l'ordre des annonces, prête à écrire en JSON, CSV ou dans une base de données.

[
  {
    "name": "Tower Mangal",
    "cuisine": "Turkish, Mediterranean",
    "rating": "4.5(26)",
    "link": "https://www.just-eat.co.uk/restaurants-tower-mangal-southwark/menu"
  },
  {
    "name": "Sud Italia",
    "cuisine": "Pizza, Italian",
    "rating": "3(2)",
    "link": "https://www.just-eat.co.uk/restaurants-sud-italia-aldgate/menu"
  }
]

Étape 5 : Scraper le menu d'un restaurant

Le lien de l'annonce pointe directement vers la page de menu d'un restaurant, qui contient le détail plus approfondi : les plats, leurs prix et leurs descriptions, groupés par catégorie. La page de menu est aussi rendue en JavaScript et paginée par défilement, donc la logique de récupération ressemble à celle des annonces. Inspectez une page de menu de la même manière, et vous trouvez ces éléments :

• Catégorie : une <section> avec data-qa="item-category" ; son nom se trouve dans le <h2> avec data-qa="heading".
• Nom du plat : à l'intérieur du <h2> de l'article avec data-qa="heading".
• Prix du plat : à l'intérieur d'un <span> dont la classe commence par formatted-currency-style.
• Description du plat : à l'intérieur d'un <div> dont la classe commence par new-item-style_item-description.

Comme les classes de prix et de description sont générées avec un préfixe stable, l'analyseur correspond au préfixe avec le sélecteur d'attribut [class^="..."] plutôt qu'au nom de classe complet et volatile. Un petit appel re.sub comprime les séquences d'espaces blancs que Just Eat laisse dans les longues descriptions.

import csv
import json
import re
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
MENU_FIELDS = ["category", "name", "price", "description"]

def fetch_menu_page(url):
    options = {"scroll": "true", "scroll_interval": "15"}
    response = api.get(url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8")
    print(f"Failed to fetch the menu page. Status: {response['status_code']}")
    return None

def text_of(node, selector, default=""):
    el = node.select_one(selector)
    return el.get_text(strip=True) if el else default

def parse_menu(html):
    soup = BeautifulSoup(html, "html.parser")
    menu = []
    categories = soup.select('section[data-qa="item-category"]')
    for category in categories:
        category_name = text_of(category, 'h2[data-qa="heading"]', "Uncategorized")
        items = category.select('div[data-qa="item-category-list"] div[data-qa="item"]')
        for item in items:
            description = text_of(item, 'div[class^="new-item-style_item-description"]')
            menu.append({
                "category": category_name,
                "name": text_of(item, 'h2[data-qa="heading"]'),
                "price": text_of(item, 'span[class^="formatted-currency-style"]'),
                "description": re.sub(r"\s+", " ", description),
            })
    return menu

def export_menu(rows, name="just_eat_menu"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=4, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=MENU_FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} menu items to {name}.json and {name}.csv")

def main():
    menu_url = "https://www.just-eat.co.uk/restaurants-tower-mangal-southwark/menu"
    html = fetch_menu_page(menu_url)
    if not html:
        return
    rows = parse_menu(html)
    export_menu(rows)

if __name__ == "__main__":
    main()

La page de menu défile également, donc fetch_menu_page utilise la même option scroll avec un scroll_interval plus court de 15 secondes, car la plupart des menus sont plus petits que la grille de restaurants d'une zone animée. parse_menu parcourt chaque section data-qa="item-category", lit le titre de catégorie une fois, puis boucle les articles à l'intérieur et enregistre le nom du plat, le prix et la description nettoyée. Pour aller plus loin, alimentez-le avec les valeurs de link de votre export d'annonces et cadencez les requêtes avec un court délai entre les restaurants, de la même façon qu'entre les pages de zones.

À quoi ressemble le résultat du menu

Chaque article du menu devient un enregistrement plat tagué avec sa catégorie, de sorte que l'export se charge proprement dans un tableur ou un pipeline de comparaison de prix.

[
  {
    "category": "What's New?",
    "name": "Terry's Chocolate Orange Pie",
    "price": "£2.49",
    "description": "Crispy chocolate pastry filled with a chocolate orange ganache."
  },
  {
    "category": "What's New?",
    "name": "Large Grimace Shake",
    "price": "£3.99",
    "description": "Milkshake base blended with blueberry-flavour syrup."
  }
]

Mise à l'échelle sur plusieurs zones et rester débloqué

Une page de zone est une démonstration ; un vrai travail de recherche s'étend sur de nombreux codes postaux puis plonge dans le menu de chaque restaurant. Just Eat expose une page de zone pour chaque code postal à sa propre URL /area/, donc vous gardez une liste de codes postaux, scrappez chaque zone, puis suivez le link de chaque restaurant vers le scraper de menu. Quelques habitudes permettent de maintenir ce run plus large en bonne santé, et elles s'appliquent à toute cible commerciale difficile.

• Cadencez vos requêtes. Mettez un délai entre les pages de zones et entre les récupérations de menus plutôt que de tout envoyer d'un coup. Planifiez les travaux plus lourds aux heures creuses pour alléger la charge sur les serveurs du site.
• Misez sur la rotation. Un pool d'adresses IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels, de sorte qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous montez votre propre infrastructure, c'est la partie à soigner.
• Calibrez le défilement. Définissez scroll_interval pour correspondre à la densité de chaque page, afin de charger chaque carte sans payer pour un défilement à vide sur une liste courte.
• Conservez uniquement ce dont vous avez besoin. Stockez les champs d'annonces et de menus que votre projet utilise et écartez le reste. Revérifiez périodiquement vos sélecteurs data-qa pour que le scraper suive les changements de balisage.

Pour un guide plus complet sur l'évitement des blocages, consultez comment scraper des sites web sans se faire bloquer, et pour en savoir plus sur l'importance du rendu ici, comment crawler des sites JavaScript. Si vous débutez dans le scraping Python, scraper un site web avec Python couvre les fondamentaux, et pour transformer les prix des menus en flux de comparaison, le web scraping pour l'intelligence des prix montre vers où mène ces données.

Est-il légal de scraper Just Eat ?

La légalité du scraping de Just Eat dépend des conditions générales de Just Eat, de votre juridiction et de l'usage que vous faites des données. Les conditions de Just Eat restreignent l'accès automatisé, donc le scraping peut aller à l'encontre de ces conditions, quelle que soit la prudence de vos outils. Aucun code présenté ici ne change cela ; il se contente de faire fonctionner la partie technique. Lisez les conditions générales de Just Eat et son robots.txt, et traitez les deux comme la limite de ce que vous collectez. Pour un usage commercial ou concurrentiel, le tableau juridique se complexifie, et consulter un expert juridique sur votre cas spécifique est la démarche raisonnable.

Quelques règles à respecter. Collectez uniquement des données publiques : les noms de restaurants, cuisines, notes, liens d'annonces et articles de menus que chacun peut voir sur une page de zone ou de menu sans compte. Maintenez votre volume de requêtes suffisamment bas pour ne pas surcharger les serveurs de Just Eat, et évitez les données personnelles, y compris tout ce qui est lié à des clients, des évaluateurs ou des personnes nommées identifiables au-delà de ce qui est listé publiquement. Les descriptions de plats et les photos d'un menu sont le contenu protégé par le droit d'auteur du restaurant, ne les republiez donc pas en masse comme s'ils vous appartenaient.

Ce guide est délibérément limité aux pages publiques de zones et de menus parce que c'est la ligne qui rend le travail défendable. Il ne couvre pas ce qui se trouve derrière une connexion, l'historique des comptes ou des commandes, les détails de paiement, ni aucune tentative de contourner l'authentification ou un CAPTCHA auquel vous n'êtes pas autorisé à accéder. Si votre projet nécessite plus que des données d'annonces publiques, ou une structure garantie et des droits commerciaux, un partenariat officiel ou un accord de données avec Just Eat est la bonne voie, pas un scraper plus sophistiqué.

Foire aux questions

Pourquoi une simple requête ne renvoie-t-elle pas de restaurants de Just Eat ?

Just Eat rend sa grille de restaurants côté client et charge plus de cartes à mesure que vous faites défiler, donc une requête brute obtient souvent une coquille vide. En plus de cela, le site challenge ou bloque le trafic qui ne ressemble pas à un vrai navigateur. Rendre la page via la Crawling API derrière une adresse IP de confiance, avec l'option de défilement activée, résout les deux, c'est pourquoi le scraper ici route sa requête à travers elle.

Comment scraper Just Eat pour une zone spécifique ?

Chaque zone Just Eat possède sa propre URL /area/ stable basée sur le code postal, par exemple /area/ec4r3tn pour la zone London Bridge. Pointez le scraper vers l'URL de zone que vous souhaitez. Pour couvrir de nombreuses zones, gardez une liste de codes postaux et bouclez sur leurs URLs, en cadençant les requêtes avec un court délai entre elles.

Puis-je extraire les informations de menu pour des restaurants spécifiques ?

Oui. Le champ link de chaque annonce pointe directement vers la page de menu du restaurant. Passez cette URL au scraper de menu pour extraire le nom du plat, le prix et la description groupés par catégorie. La page de menu est rendue en JavaScript et paginée par défilement comme la page de zone, donc la même option scroll charge le menu complet avant l'analyse.

Comment le scraper gère-t-il le défilement infini de Just Eat ?

Just Eat utilise une pagination par défilement plutôt que des pages numérotées. Au lieu d'automatiser le défilement vous-même, passez scroll: "true" et un scroll_interval en secondes à la Crawling API, qui fait défiler la page côté serveur jusqu'à la fin de l'intervalle, puis retourne le HTML entièrement chargé. Augmentez l'intervalle pour les zones plus denses et diminuez-le pour les menus courts.

Pourquoi utiliser les sélecteurs data-qa plutôt que les noms de classes ?

Just Eat envoie des noms de classes utilitaires générés qui changent sans préavis, tandis que ses attributs data-qa existent pour les propres tests automatisés du site et restent plus stables entre les versions. Cibler data-qa="restaurant-card" ou data-qa="item-category" vous donne un ancrage plus robuste. Pour le prix et la description, qui utilisent des classes générées avec un préfixe fixe, l'analyseur correspond à ce préfixe avec un sélecteur [class^="..."].

Comment éviter d'être bloqué lors du scraping de Just Eat ?

Maintenez votre taux de requêtes par adresse IP bas, ajoutez un délai entre les récupérations de zones et de menus, et routez via des adresses IP résidentielles rotatives pour qu'aucune adresse individuelle ne déclenche une limite de débit. La Crawling API gère la rotation, un pool d'adresses IP de confiance et la gestion des CAPTCHA pour vous ; si vous construisez votre propre infrastructure, c'est la partie dans laquelle investir. Surveillez les codes de statut et ralentissez quand vous commencez à voir des challenges.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.