How to Use Hugging Face: The Hub, Spaces, and Inference, Without Drowning

How do you use Hugging Face? Treat it as five separate products that happen to share a login: Models (weights), Datasets (training and eval data), Spaces (running demos), Inference Providers (an API to call those models), and Jobs (rented GPUs). Decide which two you need before you browse, install the hf CLI, and pull one model. Everything else is noise until then.

That framing matters because the Hub is enormous and mostly inert. As I write this the Models page reports 3,068,981 models, the Datasets page 1,049,117 datasets, and Spaces 1,473,372 apps. Nobody can evaluate that. What you can do is learn the shape of the place, then filter like the distribution is lopsided, because it is.

TL;DR

• Hugging Face is five products: Models, Datasets, Spaces, Inference Providers, Jobs. Most builders need two. Pick them first.
• The Hub holds over 3 million models, but Hugging Face's own Summer 2026 report found roughly 85.6% have fewer than 200 lifetime downloads and 1.5% of repos account for 99.2% of downloads. Sort by downloads, not by new.
• You do not need a GPU. Inference Providers exposes one OpenAI-compatible endpoint at https://router.huggingface.co/v1, and the pricing docs state Hugging Face passes provider rates through with no markup.
• Free accounts get $0.10 of monthly inference credit, PRO gets $2.00. ZeroGPU gives 5 free GPU minutes a day on a free account and 40 on PRO.
• Jobs rents real hardware by the second: cpu-basic at $0.01/hour, t4-small at $0.40/hour, a100-large at $2.50/hour. Default timeout is 30 minutes, so set one.

The five surfaces, and which two you need

Almost every "I don't get Hugging Face" complaint is a category error. Someone wants an API and lands on a page of .safetensors files. Someone wants to fine-tune and ends up clicking through a Gradio demo. The surfaces do genuinely different things.

If you are shipping a product feature, you want Models and Inference Providers. If you are training something, you want Datasets and Jobs. If you are showing a client a working thing this afternoon, you want Spaces. Those are three different afternoons, and mixing them is how people lose a week.

Filter like 98.5% of it is noise, because it is

The single most useful fact about the Hub is how concentrated it is. Hugging Face published a State of Open Models report for Summer 2026 covering January through August, and it found roughly 85.6% of models have fewer than 200 lifetime downloads while 1.5% of repositories account for 99.2% of all downloads. The same report tracked public model repos going from 2.43 million to 2.96 million over those months, datasets from 711,000 to 1 million, and Spaces from 1.00 million to 1.44 million.

Read that as permission to be ruthless. Your filtering sequence:

1. Pick the task from the left sidebar first (text classification, automatic speech recognition, feature extraction, whatever you actually need). This cuts three million to a few thousand.
2. Sort by downloads, not by "recently updated". Recency selects for someone's Tuesday experiment.
3. Open three candidates and read the model card for exactly three things: the license, whether weights ship as safetensors, and whether there is a stated eval number you can check.
4. Check the model page sidebar for which inference providers serve it. If none do, you are committing to hosting it yourself, which is a different project.

No card, no license, no eval means no dependency. That rule alone removes most of the Hub. If you want the longer version of the hosting-versus-API decision, I wrote it up in open source AI, and the model selection method in how to choose an AI model.

The first twenty minutes

Install the CLI, authenticate, and pull one model. The command was renamed: it is hf now, not huggingface-cli.

curl -LsSf https://hf.co/cli/install.sh | bash
hf auth login
hf download sentence-transformers/all-MiniLM-L6-v2

hf download prints the local cache path, which is the thing beginners miss. Models do not land in your project folder. They land in a shared cache, and every library that reads that cache gets the same copy.

Pulling a dataset or a Space is the same command with a flag:

hf download HuggingFaceH4/ultrachat_200k --repo-type dataset

Then run something. In Python, transformers hides the loading entirely:

from transformers import pipeline
clf = pipeline("sentiment-analysis")
print(clf("The invoice import finally worked."))

That is the whole loop: authenticate, pull, call. If you are on a Mac with no GPU, small models like MiniLM run on CPU in tens of milliseconds, which is fast enough for embedding a document library. That use case is covered in what are embeddings.

One detail worth knowing if you work in Claude Code or a similar agent: the installer also ships an hf-cli skill, and hf skills add --claude wires it into Claude Code so the agent knows the current command surface instead of guessing at the old huggingface-cli syntax.

Inference Providers: the part that replaces a GPU

This is the surface most people should start with and most tutorials bury. Hugging Face runs a router that speaks the OpenAI API. You point the standard client at a different base URL and you are done.

from openai import OpenAI
client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)
r = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Summarize this ticket in one line."}],
)

The billing model is the interesting part. Per the Inference Providers pricing docs, Hugging Face charges the same rates as the underlying provider with no additional fees, and every account gets monthly credits: $0.10 for free users, $2.00 for PRO, $2.00 per seat for Team and Enterprise. Those PRO credits are general compute credits, so the same $2.00 can be spent on Inference Endpoints, upgraded Spaces hardware, or Jobs.

The catch: not every model on the Hub has a provider serving it. Check the providers listed on the model page before you write code, or your first request returns nothing useful.

Spaces: a demo with a URL, in an afternoon

A Space is a Git repo that Hugging Face runs for you. Push a Gradio app, get a public URL. CPU Basic hardware is free on the pricing page, which is enough for anything that calls an API rather than loading a model.

For GPU demos, the thing to understand is ZeroGPU. It dynamically allocates NVIDIA RTX Pro 6000 Blackwell GPUs only while a decorated function runs, so an idle demo costs nothing. The ZeroGPU docs set the daily quota at 2 minutes unauthenticated, 5 minutes on a free account, and 40 minutes on PRO, Team, or Enterprise. Hosting limits are 2 ZeroGPU Spaces on a free account in good standing and 10 on PRO. Past the quota, PRO and above burn credits at $1 per 10 minutes of GPU time.

Two constraints that bite people: ZeroGPU is Gradio-only, and your model has to be moved to cuda at module level, not lazily inside the decorated function.

import spaces

@spaces.GPU(duration=120)
def generate(prompt):
    return pipe(prompt).images

If a client demo is the goal, this is the cheapest path from model to link that exists.

Jobs: rented hardware, billed by the second

Jobs is the surface almost nobody mentions and the one that changed how I do batch work. It is docker run against Hugging Face infrastructure, available to any account with a positive credit balance, billed per second.

hf jobs run --flavor t4-small --timeout 1h \
  pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel python train.py

The published hardware table in the Jobs guide runs from cpu-basic at $0.01/hour through t4-small at $0.40, a10g-small at $1.00, a100-large at $2.50, and h200 at $5.00. Do the arithmetic before you assume this is expensive: a 40-minute fine-tune on an A10G is 67 cents. A nightly 10-minute data job on cpu-upgrade at $0.03/hour is under two cents a month.

The trap is the default 30-minute timeout, which will kill a training run silently. Set --timeout explicitly on anything longer than a smoke test. Jobs also takes a cron schedule (hf jobs scheduled run @daily ...) and can mount a Hub repo read-only with -v hf://datasets/org/name:/data, which means a recurring eval or a nightly dataset refresh is one command rather than a server you maintain.

Where Hugging Face is the wrong answer

Honest limits, because the Hub is not a frontier-model replacement. Stanford HAI's 2026 AI Index reports that as of March 2026 the top closed model leads the top open model by 3.3%, up from 0.5% in August 2024. On open-ended reasoning, agentic work, and long-context tasks, a frontier API is still the better buy, and the operational cost of running your own weights is a real line item.

Where the Hub wins is the machinery underneath: embeddings, classification, reranking, transcription, OCR, translation, and anything that cannot leave your network. Those run on models measured in hundreds of megabytes, often on CPU, at a cost that rounds to zero per call. My working split is a frontier model for judgment and open models on the Hub for volume. The same logic drives the build-versus-tune decision in RAG vs fine-tuning.

The bottom line

Hugging Face is not hard, it is just five products wearing one coat. Name the two you need, filter the Hub like 98.5% of it is dead weight (because by download share it is), and start on the router rather than on your own GPU. The first real thing to ship is small: pull one embedding model, index a folder of documents, and see how far a 90MB model gets you before you reach for anything larger. If it holds, you have replaced an API line item with a file on disk.

Every tool in this post lives in the stack I actually run. Grab THE AI DAILY DRIVER STACK for the full working set, then join the newsletter and I will send the next build, with the arithmetic, before it goes anywhere else.