In this Article
Si vous vous demandez où les développeurs se sentent chez eux, soutenus et connectés, GitHub est l’endroit idéal. Que vous codiez seul ou au sein d’une entreprise technologique internationale, cette plateforme est incontournable pour accéder à des données techniques. GitHub propose une API officielle et complète qui devrait, dans bien des cas, être votre premier choix. Toutefois, lorsque les données dont vous avez besoin ne sont pas accessibles via l’API, le web scraping peut constituer une alternative utile.
Ce tutoriel s’adresse à toutes les personnes qui souhaitent en savoir plus sur GitHub, ses principaux éléments et la manière de scraper les repositories tendance.
*Le web scraping doit toujours être effectué dans le cadre des limites juridiques et éthiques. Nous n’encourageons pas les activités illégales et mettons uniquement en avant des stratégies d’utilisation responsable.
I am raw html block.
Click edit button to change this html
Qu’est-ce que GitHub et comment fonctionne-t-il ?
GitHub est devenu une plateforme centrale pour les développeurs du monde entier. Elle permet d’héberger du code, de collaborer sur des projets et de créer des logiciels. Son nom repose sur Git, un système de contrôle de version sur lequel GitHub est construit. Il vous simplifie la vie : nul besoin de sauvegarder plusieurs fichiers, car Git conserve l’historique complet des modifications au même endroit. Vous pouvez à tout moment voir ce qui a été modifié, quand, et par qui. C’est particulièrement utile pour le travail en équipe.
Les forks, repositories, étoiles et branches peuvent sembler un peu déroutants au début. Mais une fois le fonctionnement de Git compris, ces notions prennent tout leur sens. Dans Git, un repository contient votre projet et son historique ; il enregistre les modifications au fil du temps, les branches permettent le développement en parallèle et la fusion intègre le travail terminé au projet principal. Voici un schéma simple pour visualiser ce flux :
Nous vous conseillons de vérifier ces conditions au préalable ; vous pouvez les trouver sur leur site officiel.
En bref, ce système permet aux développeurs de travailler ensemble sans écraser le travail de chacun.
* Est-il légal de scraper GitHub ?
Oui, c’est généralement légal à condition de respecter ses conditions d’utilisation et respecter les règles de droit d’auteur et de confidentialité. Les référentiels publics, les profils d’utilisateurs et les métadonnées telles que les étoiles, les forks et les commits sont accessibles sans enfreindre la loi.
En revanche, l’accès à des repositories privés, à des informations sensibles sur les utilisateurs, ou les accès automatisés qui dépassent les limites de débit de GitHub peuvent entraîner la suspension d’un compte ou des conséquences juridiques. Veillez toujours à ce que vos activités de scraping soient éthiques, respectent la confidentialité des utilisateurs et ne surchargent pas les serveurs de GitHub.
Comment GitHub gère-t-il le scraping et les abus ?
Comme de nombreuses grandes plateformes, GitHub applique des limites de débit strictes afin de préserver sa stabilité et d’empêcher les abus automatisés. Chaque jeton API ou compte authentifié dispose d’un nombre fixe de requêtes par heure, soit environ 5,000 requêtes. Atteindre cette limite entraîne généralement des réponses 403 Forbidden. En cas de comportement abusif, les utilisateurs risquent une suspension temporaire ou définitive de leur compte. Face aux tentatives répétées de bots, GitHub surveille les anomalies de trafic, les rafales d’adresses IP et les échecs d’authentification répétés.
Pour collecter des données tout en restant dans des seuils acceptables, les développeurs peuvent utiliser des proxys comme solution de secours. Les proxys alternent les adresses IP source entre les requêtes sortantes et répartissent le trafic entre plusieurs endpoints, ce qui réduit le risque de déclencher les systèmes anti-abus de GitHub. Pour choisir le type de proxy adapté, tenez compte notamment du volume de collecte et de la sensibilité des données. Les proxys DataImpulse sont abordables et réputés pour leur fiabilité et leur vitesse. Nous vous recommandons de les utiliser de manière responsable et éthique sans enfreindre les règles de la plateforme.
Respectez les règles de l’API GitHub et évitez de scraper des repositories privés ou des données sensibles d’utilisateurs.
Configuration initiale : que faut-il télécharger ?
- Python 3 (dernière version)
Téléchargez-le ici, puis installez l’extension Python dans VS Code. Ouvrez un terminal et vérifiez son installation avec :
python3 --version
- Visual Studio Code (ou un autre éditeur de code, la dernière version)
Téléchargez-le ici, installez et ouvrez votre dossier de projet.
- Identifiants de proxy depuis le tableau de bord DataImpulse
Connectez-vous à DataImpulse et copiez vos identifiants de connexion au proxy.
- Bibliothèques : Requests et BeautifulSoup ; sys et typing (modules Python intégrés).
Requests : utilisé pour envoyer des requêtes HTTP.
BeautifulSoup : utilisé pour analyser le HTML et extraire les données des pages tendance de GitHub.
sys : utilisé pour arrêter le programme avec un message d’erreur en cas de problème (sys.exit(…)).
typing : fournit des annotations qui précisent les types de données attendus pour chaque fonction.
Commencez par ouvrir le terminal sur votre ordinateur et assurez-vous que pip est installé :
python3 -m ensurepip
Installez ensuite les bibliothèques Python avec :
pip3 install requests beautifulsoup4
Appuyez sur Entrée pour lancer l’installation.
Étapes courantes pour scraper GitHub avec Python
- Choisissez la page cible – Déterminez quelle page GitHub ou quelles données de repository vous souhaitez collecter (par exemple, référentiels de tendances, profils d’utilisateurs).
- Inspecter la structure HTML – Examinez le HTML de la page pour identifier les éléments qui contiennent les données requises.
- Envoyer des requêtes HTTP – Utilisez une bibliothèque comme Requests pour récupérer le contenu de la page.
- Analyser la réponse – Utilisez BeautifulSoup pour traiter le HTML.
- Extraire les données requises – Identifiez et extrayez les informations spécifiques dont vous avez besoin.
- Gérer la pagination – Parcourez les pages pour extraire toutes les entrées disponibles.
- Enregistrer les résultats – Enregistrez les données collectées dans un CSV, JSON ou une base de données (facultatif).
Notre exemple pratique :
Pour notre cas de scraping, nous avons utilisé la page de référentiels de tendances. Avant de partager le code complet, passons brièvement en revue ses principaux composants.
- Configuration du proxy
PROXY – les identifiants proxy de votre tableau de bord DataImpulse(hôte, port, nom d’utilisateur, mot de passe). Remplacez ces valeurs par vos propres informations d’identification.
TIMEOUT – délai maximal d’une requête (20 secondes).
VERIFY_SSL – active la vérification de la connexion HTTPS.
USER_AGENT – imite un vrai navigateur pour contourner les contrôles de base des robots.
- Filtres des tendances GitHub
LANGUAGE – votre langage de programmation (peut être None pour tous).
SINCE – plage horaire : quotidien, hebdomadaire, mensuel.
TIMEOUT = 20 # seconds
VERIFY_SSL = True
USER_AGENT = (
"Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/118.0.0.0 Safari/537.36"
Voici un premier exemple de code que vous pouvez essayer :
import requests
from bs4 import BeautifulSoup
LANGUAGE = "python" # Programming language. None can be used as "Any" parameter in GitHub Trending
SINCE = "daily" # Date range: daily / weekly / monthly
PROXY = {
"host": "DATAIMPULSE HOST",
"port": "DATAIMPULSE PORT",
"user": "DATAIMPULSE LOGIN",
"pass": "DATAIMPULSE PASSWORD",
}
# Proxy configuration
proxy_url = f"http://{PROXY['user']}:{PROXY['pass']}@{PROXY['host']}:{PROXY['port']}"
proxies = {
"http": proxy_url,
"https": proxy_url,
}
# Checking proxies
ip = requests.get("https://api.ipify.org", proxies=proxies).text
print("Your IP:", ip)
# Scraping Github Trending section
url = "https://github.com/trending"
# Adding parameters like Language and Date Range, and make HTTP request to GitHub
params = {"since": SINCE}
if LANGUAGE:
params["language"] = LANGUAGE
headers = {
"User-Agent": "Mozilla/5.0"
}
r = requests.get(
url,
headers=headers,
params=params,
proxies=proxies,
timeout=20
)
# Scrape and output details
soup = BeautifulSoup(r.text, "html.parser")
print("\n🔥 GitHub Trending:\n")
for count, repo in enumerate(soup.select("article.Box-row"), start=1):
name = repo.h2.text.strip().replace("\n", "").replace(" ", "")
link = "https://github.com" + repo.h2.a["href"]
desc = repo.p.text.strip() if repo.p else "No description"
stars_today = repo.select_one("span.d-inline-block.float-sm-right").text.strip() if repo.select_one("span.d-inline-block.float-sm-right") else None
print(f"{count}. {name}")
print(f"Link: {link}")
print(f"Stars Today: {stars_today}")
print(f"Description: {desc}")
print("-" * 40)
Dans l’extrait de code suivant, nous utiliserons des fonctions. Elles rendent le code plus propre, réutilisable, plus facile à déboguer et à maintenir, ce qui est particulièrement important pour des tâches complexes comme le scraping de GitHub ou la gestion de plusieurs proxys.
- Fonctions
enregistrer – formate la sortie de la console.
build_proxies – construit une chaîne proxy (nom d’utilisateur : mot de passe @ hôte : port).
test_proxy – vérifie le proxy via https://api.ipify.org?format=json.
scrape_github_trending – analyse le HTML à l’aide de BeautifulSoup4.
principal – démarre le processus de grattage.
Voici la version complète du code :
import sys
import requests
from bs4 import BeautifulSoup
from typing import List, Dict, Optional
# =========================================================
# CONFIG — CHANGE ONLY THIS SECTION
# =========================================================
GITHUB_TRENDING_URL = "https://github.com/trending"
# Proxy configuration (leave PROXY = None to disable proxy)
PROXY = {
"host": "DATAIMPULSE HOST",
"port": "DATAIMPULSE PORT",
"username": "DATAIMPULSE LOGIN",
"password": "DATAIMPULSE PASSWORD",
}
# PROXY = None # uncomment to disable proxy completely
LANGUAGE = "python" # e.g. "python", "javascript", or None
SINCE = "daily" # "daily", "weekly", "monthly"
TIMEOUT = 20 # seconds
VERIFY_SSL = True
USER_AGENT = (
"Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/118.0.0.0 Safari/537.36"
)
# =========================================================
# END CONFIG
# =========================================================
def log(msg: str) -> None:
print(f"[INFO] {msg}")
def build_proxies(proxy_cfg: Optional[Dict]) -> Optional[Dict[str, str]]:
if not proxy_cfg:
return None
proxy_url = (
f"http://{proxy_cfg['username']}:{proxy_cfg['password']}"
f"@{proxy_cfg['host']}:{proxy_cfg['port']}"
)
return {
"http": proxy_url,
"https": proxy_url,
}
def test_proxy(proxies: Optional[Dict[str, str]]) -> None:
log("Testing proxy...")
r = requests.get(
"https://api.ipify.org?format=json",
proxies=proxies,
timeout=10,
)
r.raise_for_status()
log(f"Proxy OK. Outgoing IP: {r.json()['ip']}")
def scrape_github_trending(
language: Optional[str],
since: str,
proxies: Optional[Dict[str, str]],
timeout: int,
) -> List[Dict]:
headers = {"User-Agent": USER_AGENT}
params = {"since": since}
if language:
params["language"] = language
log("Fetching GitHub Trending page...")
response = requests.get(
GITHUB_TRENDING_URL,
headers=headers,
params=params,
proxies=proxies,
timeout=timeout,
verify=VERIFY_SSL,
)
response.raise_for_status()
soup = BeautifulSoup(response.text, "lxml")
repos = []
for article in soup.select("article.Box-row"):
name = (
article.h2.text
.replace("\n", "")
.replace(" ", "")
.strip()
)
url = "https://github.com" + article.h2.a["href"]
description = article.p.text.strip() if article.p else None
language_el = article.select_one(
'[itemprop="programmingLanguage"]'
)
stars_today_el = article.select_one(
"span.d-inline-block.float-sm-right"
)
repos.append({
"name": name,
"url": url,
"description": description,
"language": (
language_el.text.strip()
if language_el else None
),
"stars_today": (
stars_today_el.text.strip()
if stars_today_el else None
),
})
return repos
def main() -> None:
proxies = build_proxies(PROXY)
# 1) Test proxy
try:
if proxies:
test_proxy(proxies)
else:
log("Proxy disabled.")
except Exception as e:
sys.exit(f"[ERROR] Proxy test failed: {e}")
# 2) Scrape GitHub Trending
try:
repos = scrape_github_trending(
language=LANGUAGE,
since=SINCE,
proxies=proxies,
timeout=TIMEOUT,
)
except Exception as e:
sys.exit(f"[ERROR] Scraping failed: {e}")
# 3) Output
print("\n🔥 GitHub Trending Repositories\n")
print(f"Language: {LANGUAGE or 'All'} | Since: {SINCE}\n")
for i, repo in enumerate(repos, 1):
print(f"{i}. {repo['name']}")
print(f" URL: {repo['url']}")
print(f" Language: {repo['language']}")
print(f" Stars today: {repo['stars_today']}")
if repo["description"]:
print(f" Description: {repo['description']}")
print()
log(f"Done. Total repositories: {len(repos)}")
if __name__ == "__main__":
main()
Le terminal affiche alors une liste claire de 14 repositories tendance.
Réflexions finales et recommandations
Scraper GitHub est une compétence utile, mais il est essentiel d’en respecter les aspects éthiques et techniques. Les débutants peuvent aussi commencer avec Gemini Bot, qui extrait des données structurées sans code. Il suffit de créer un bot et de saisir un prompt comme celui-ci :
Analysez cette page de repository GitHub et extrayez les informations suivantes :
– Nom du référentiel
– Nombre d’étoiles
– Langage de programmation principal
– Date du dernier commit
Renvoyez les données au format JSON.
Et voilà. Nous encourageons toutefois les développeurs à tester de nouvelles idées, à combiner des outils et à adapter les méthodes à leurs projets. Utilisez des proxys, respectez toujours les conditions d’utilisation de GitHub, servez-vous de filtres pour cibler certaines langues ou périodes, journalisez et surveillez les requêtes, puis commencez avec quelques repositories avant de monter progressivement en charge.