En bref (août 2026) : Hugging Face est la plateforme centrale de l'IA open-source, avec plus de 2 millions de checkpoints de modèles, plus de 500 000 datasets et plus d'un million d'applications de démonstration interactives appelées Spaces. Vous pouvez tester n'importe quel modèle public dans votre navigateur sans configuration, appeler des modèles par programme via un token unique acheminé vers 18 partenaires de compute en inférence, ou télécharger et exécuter des modèles en local grâce à la bibliothèque Python transformers. Un compte gratuit couvre la plupart des expérimentations, dont cinq minutes de GPU quotidien via ZeroGPU ; le plan PRO est à 9 $/mois ; les plans d'organisation Team et Enterprise démarrent respectivement à 20 $ et 50 $ par utilisateur et par mois, avec le compute facturé séparément en supplément de tous les plans.

Dernière vérification : 31 août 2026, d'après la documentation officielle et les pages tarifaires.

Ce qu'est Hugging Face

Hugging Face est à la fois une plateforme, une communauté et un écosystème de bibliothèques. La pièce centrale est le Hub sur huggingface.co : un hébergeur de dépôts basé sur Git, conçu pour les artefacts IA. Chaque modèle, dataset et Space est un dépôt versionné avec historique de commits, branches, pull requests et fils de discussion. Les dépôts utilisent Xet, une couche de stockage pour fichiers volumineux qui déduplique les blocs entre les uploads et accélère les transferts.

La plateforme est neutre vis-à-vis des familles de modèles. On y trouve des checkpoints de Meta, Google, Microsoft, Mistral, DeepSeek, EleutherAI et de milliers de contributeurs indépendants. Les licences varient : de nombreux modèles populaires sont sous Apache 2.0 et utilisables commercialement ; d'autres restreignent l'usage commercial ou exigent de soumettre une demande d'accès et d'accepter des conditions avant le téléchargement.

Trois systèmes interconnectés composent la plateforme :

• Le Hub : dépôts versionnés pour modèles, datasets et Spaces, chacun avec des visionneuses navigateur et des widgets d'inférence en direct
• Inference Providers : un routeur d'API serverless qui achemine vos requêtes vers l'un des 18 partenaires de compute (Groq, Together AI, Cerebras, Replicate, fal.ai, entre autres) via un token Hugging Face unique
• La bibliothèque transformers : une bibliothèque Python avec plus de 164 000 étoiles sur GitHub pour charger n'importe quel modèle du Hub et l'exécuter sur votre propre matériel

Créer votre compte et obtenir un token

Créez un compte gratuit sur huggingface.co. Aucune carte bancaire n'est requise. Une fois connecté, rendez-vous dans Settings > Access Tokens pour créer un token API.

Pour les Inference Providers (l'API serverless), générez un token à granularité fine avec la permission "Make calls to Inference Providers" activée. Pour l'upload de modèles ou la lecture de dépôts privés, un token standard en lecture/écriture suffit.

Pour vous authentifier depuis votre terminal, installez le CLI et connectez-vous :

macOS / Linux standalone installer (recommended)

curl -LsSf https://hf.co/cli/install.sh | bash

or via pip

pip install huggingface_hub
hf auth login

hf auth login demande votre token et le stocke dans ~/.cache/huggingface/token. Toutes les bibliothèques HF lisent ensuite ce cache automatiquement. Pour les environnements CI/CD et Docker, définissez directement la variable d'environnement HF_TOKEN plutôt que d'utiliser la commande de connexion.

Trouver et tester des modèles sans écrire de code

Le navigateur de modèles sur huggingface.co/models permet de filtrer par tâche, bibliothèque, langue, dataset et licence. Filtres de tâches courants :

• text-generation pour les grands modèles de langage
• automatic-speech-recognition pour la transcription (Whisper et ses variantes)
• text-to-image pour les modèles de diffusion
• feature-extraction pour les modèles d'embeddings utilisés dans la recherche et le RAG (retrieval-augmented generation)

Chaque page de modèle comprend une Model Card couvrant les usages prévus, les limitations connues, les données d'entraînement et les résultats d'évaluation. Sous la card se trouve un widget d'inférence en direct, alimenté par les Inference Providers : saisissez un prompt et obtenez une réponse directement sur la page, sans code.

Pour comparer des modèles de chat côte à côte, l'Inference Playground sur huggingface.co/playground vous permet d'exécuter le même prompt sur plusieurs modèles simultanément.

Les modèles à accès restreint (Llama, Gemma et autres) affichent un bouton de demande d'accès en haut de la page. Vous devez soumettre une demande et accepter les conditions de licence avant de télécharger les poids ou d'appeler le modèle via l'API. L'approbation est généralement automatisée et quasi instantanée pour la plupart des variantes Llama.

Appeler n'importe quel modèle depuis votre code

Inference Providers propose une API unique acheminant vers 18 partenaires de compute sans majoration sur les tarifs des fournisseurs. L'URL de base https://router.huggingface.co/v1 est compatible OpenAI pour les complétions de chat, ce qui permet d'utiliser le SDK Python ou JavaScript d'OpenAI en changeant une seule ligne.

Installez le client Hugging Face Hub :

pip install huggingface_hub

Appelez un modèle de langage avec le client natif :

from huggingface_hub import InferenceClient
import os

client = InferenceClient(token=os.environ["HF_TOKEN"])

completion = client.chat.completions.create(
model="openai/gpt-oss-120b", # append :fastest, :cheapest, or :preferred
messages=[{"role": "user", "content": "Explain backpropagation in two sentences."}],
)
print(completion.choices[0].message.content)

Si vous utilisez déjà le client Python d'OpenAI, changez simplement l'URL de base :

from openai import OpenAI
import os

client = OpenAI(
base_url="https://router.huggingface.co/v1",
api_key=os.environ["HF_TOKEN"],
)

La sélection du fournisseur est contrôlée par un suffixe sur l'identifiant du modèle. :fastest (par défaut) choisit le fournisseur offrant le débit le plus élevé pour ce modèle. :cheapest minimise le coût par token en sortie. Vous pouvez épingler un fournisseur spécifique par son nom, par exemple "openai/gpt-oss-120b:groq".

L'endpoint compatible OpenAI couvre uniquement les complétions de chat. Pour la génération d'images, les embeddings et la reconnaissance vocale, utilisez directement les méthodes de InferenceClient :

image = client.text_to_image(
prompt="A mountain lake at dawn, photorealistic",
model="black-forest-labs/FLUX.1-dev"
)
image.save("output.png")

Exécuter des modèles en local avec la bibliothèque Transformers

Pour une utilisation hors ligne, du fine-tuning ou quand vous avez besoin d'un contrôle total sur la pile d'inférence, téléchargez et exécutez les modèles en local avec transformers.

Installez les bibliothèques principales :

pip install -U transformers datasets evaluate accelerate timm

La fonction pipeline() est le chemin le plus rapide vers l'inférence locale. Elle télécharge et met en cache les poids du modèle depuis le Hub au premier appel :

from transformers import pipeline
from accelerate import Accelerator

device = Accelerator().device # auto-selects CUDA, Apple MPS, or CPU

Text generation

gen = pipeline("text-generation", model="meta-llama/Llama-2-7b-hf", device=device)
print(gen("The transistor was invented in", max_length=60))

Automatic speech recognition

asr = pipeline("automatic-speech-recognition", model="openai/whisper-large-v3", device=device)
print(asr("interview.flac"))

Pour un contrôle plus fin, utilisez directement AutoModel et AutoTokenizer :

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-7b-hf",
dtype="auto", # loads in the checkpoint's stored precision
device_map="auto", # allocates layers to the fastest device first
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

dtype="auto" est important : sans ce paramètre, PyTorch bascule par défaut en float32, ce qui double la VRAM nécessaire pour un modèle stocké en bfloat16. device_map="auto" gère automatiquement les configurations multi-GPU et le déchargement des poids du GPU vers le CPU.

Les poids des modèles en cache se trouvent par défaut dans ~/.cache/huggingface/hub. Définissez la variable d'environnement HF_HOME pour déplacer le cache vers un autre disque.

Pour les équipes qui construisent au-dessus de transformers, consultez le guide AI Weekly sur les assistants de codage IA pour comprendre comment ces bibliothèques s'intègrent dans des workflows de développement plus larges.

Créer et héberger une application de démonstration avec Spaces

Les Spaces constituent la couche d'applications web hébergées du Hub. Vous poussez une application Gradio ou Streamlit vers un dépôt Space, et Hugging Face la sert en HTTPS avec une URL publique. Les comptes gratuits disposent d'un CPU partagé (2 vCPU / 16 Go de RAM) sans frais.

ZeroGPU est l'option GPU du niveau gratuit. Il alloue dynamiquement des GPU NVIDIA RTX Pro 6000 Blackwell uniquement pendant qu'un utilisateur exécute activement une inférence, puis libère le GPU immédiatement. Vous ne payez rien pour le temps d'inactivité.

ZeroGPU existe en deux tailles : large (moitié du GPU, 48 Go de VRAM) et xlarge (GPU complet, 96 Go de VRAM). La taille xlarge consomme 2x votre quota journalier.

Pour utiliser ZeroGPU dans un Space Gradio :

import spaces
import gradio as gr
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained("black-forest-labs/FLUX.1-dev")
pipe.to("cuda") # placed on CUDA at startup; GPU is obtained per request only

@spaces.GPU
def generate(prompt):
return pipe(prompt).images[0]

gr.Interface(fn=generate, inputs=gr.Text(), outputs=gr.Image()).launch()

Le décorateur @spaces.GPU demande un GPU au moment de l'appel de la fonction et le libère à son retour. Chargez les modèles sur CUDA au niveau du module (en dehors de la fonction décorée) : le chargement paresseux à l'intérieur du décorateur est nettement plus lent car les transferts CUDA optimisés au démarrage sont court-circuités.

ZeroGPU fonctionne uniquement avec les Spaces Gradio. Les Spaces Docker et Streamlit nécessitent un niveau matériel loué. Les comptes gratuits peuvent héberger jusqu'à 2 Spaces ZeroGPU ; les comptes PRO jusqu'à 10 ; les comptes d'organisation (Team ou Enterprise) jusqu'à 50.

Lorsque votre quota ZeroGPU journalier est épuisé, le temps GPU supplémentaire coûte 1 $ par 10 minutes, prélevé sur un solde de crédit préfinancé que vous pouvez alimenter dans les paramètres de facturation.

Pour des endpoints GPU en fonctionnement continu et privés (API de production, serveurs de modèles dédiés), les Inference Endpoints déploient n'importe quel modèle du Hub sur du matériel géré réservé, facturé à l'heure.

Ce que les choses coûtent réellement

L'abonnement au plan et la facture compute sont séparés. L'abonnement mensuel donne accès à des fonctionnalités et des quotas d'utilisation ; l'inférence réelle et le temps GPU sont facturés en supplément.

Plan	Prix	Quota journalier ZeroGPU	Spaces ZeroGPU (hébergés)	Idéal pour
Gratuit	$0	5 minutes	2	Apprentissage et expérimentation
PRO	$9/month	40 minutes (extensible)	10	Praticiens individuels et utilisateurs avancés
Team	$20/user/month	40 minutes (extensible)	50 org-wide	Équipes nécessitant SSO, journaux d'audit et contrôles d'accès
Enterprise	$50/user/month	60 minutes (extensible)	50 org-wide	Organisations nécessitant conformité, provisionnement SCIM et support dédié

Les coûts de compute sont facturés en supplément de tout plan d'abonnement. Tarifs clés depuis la page tarifaire officielle :

• Dépassement ZeroGPU : 1 $ par 10 minutes après épuisement du quota journalier
• Matériel GPU dédié pour Spaces : T4 small à 0,40 $/heure, A100 (80 Go) à 2,50 $/heure
• Inference Endpoints (serveurs de modèles dédiés) : T4 à 0,50 $/heure, H100 à 4,50 $/heure, H200 (141 Go) à 5,00 $/heure, B200 (179 Go) à 9,25 $/heure
• Stockage Hub : 12 $/To/mois pour les dépôts publics, 18 $/To/mois pour les dépôts privés au volume de base ; des remises progressives s'appliquent au-delà de 50 To et 200 To

Pour les expériences courtes et le trafic irrégulier, Inference Providers (serverless) est presque toujours moins cher qu'un endpoint dédié. Les endpoints dédiés s'imposent quand vous avez besoin d'une latence garantie, d'exécuter un modèle privé ou fine-tuné, ou que votre trafic est suffisamment régulier pour que la facturation à l'heure batte les tarifs à la requête.

FAQ

Ai-je besoin d'un GPU pour utiliser Hugging Face ?
Pour les tests dans le navigateur et les appels à l'API Inference Providers, non : le compute s'exécute sur l'infrastructure des partenaires. Pour l'inférence locale avec transformers, un CPU suffit pour les petits modèles, mais la génération sera lente. Un GPU CUDA est recommandé pour tout modèle dépassant quelques milliards de paramètres. Apple Silicon (série M) est supporté via le backend MPS et fait tourner des modèles de taille intermédiaire à une vitesse acceptable.

Quelle est la différence entre Inference Providers et Inference Endpoints ?
Inference Providers est serverless et mutualisé : vous appelez un modèle via le routeur, les requêtes sont réparties sur les ressources de compute disponibles, et vous payez à la requête (ou piochez dans les crédits du niveau gratuit). Inference Endpoints déploie un conteneur dédié, toujours actif, exécutant votre modèle sur du matériel réservé, facturé à l'heure. Providers convient à l'expérimentation et aux charges de travail variables ; Endpoints convient aux cas d'usage en production où vous avez besoin d'une latence garantie, d'un débit constant, ou d'un modèle privé ou fine-tuné que vous ne pouvez pas exposer via le routeur mutualisé.

Puis-je utiliser des modèles Hugging Face dans des produits commerciaux ?
Cela dépend de la licence de chaque modèle, pas de votre plan Hugging Face. Vérifiez le champ licence de la Model Card avant de déployer quoi que ce soit. Les modèles sous Apache 2.0 sont généralement utilisables commercialement avec attribution. Les modèles sous la Llama 3 Community License ou les Gemma Terms of Use ont des restrictions commerciales liées au nombre d'utilisateurs ou aux catégories d'usage. Les modèles réservés à la recherche interdisent tout usage commercial. Le filtre de licence du Hub sur huggingface.co/models vous permet de rechercher par type de licence spécifique.

Comment télécharger un modèle pour l'utiliser hors ligne ?
Via le CLI : hf download meta-llama/Llama-2-7b-hf télécharge le checkpoint dans votre cache local. En Python, l'appel à from_pretrained() déclenche le même téléchargement automatiquement. Après le téléchargement, définissez HF_HUB_OFFLINE=1 comme variable d'environnement pour éviter tout appel réseau pendant l'inférence. Les fichiers en cache se trouvent dans ~/.cache/huggingface/hub sauf si vous avez défini HF_HOME.

Qu'est-ce qu'une Model Card et pourquoi est-elle importante avant un déploiement ?
Une Model Card est le fichier de documentation fourni avec chaque modèle du Hub. Elle couvre les usages prévus, les usages hors périmètre, les biais connus, les détails du dataset d'entraînement et les benchmarks d'évaluation. Pour toute équipe soumise à des exigences d'IA responsable ou à des obligations réglementaires, la Model Card est l'artefact principal pour auditer un modèle tiers avant de le mettre en production. Les modèles sans cards complètes doivent être traités comme sous-documentés, quels que soient leurs scores aux benchmarks.

Restez à jour sur ce qui sort dans l'ensemble de la pile IA. Recevez AI Weekly gratuitement, 3 numéros par semaine, lu par plus de 40 000 praticiens.