# Hugging Face API: access tokens, Hub API, Inference Providers pricing, rate limits and the Hugging Face MCP server

The Hugging Face API is three services behind one token: the Hub API at `https://huggingface.co/api` for searching and reading models, datasets and Spaces, Inference Providers at `https://router.huggingface.co/v1` for running models, and Inference Endpoints for dedicated deployments. You create the token (Hugging Face calls it a User Access Token, starting `hf_`) at huggingface.co/settings/tokens and choose read, write or fine-grained. Hub reads are free within rate limits, but since October 2026 free accounts get no monthly inference credits: running models means buying credits or paying $9 a month for PRO, which includes $2 of compute credits.

Every price, limit and step below was read from Hugging Face's documentation and pricing page on November 15, 2026, and the error bodies were recorded from live requests that day.

## How to get a Hugging Face API key (User Access Token)

Hugging Face does not issue a separate API key; a User Access Token is the key for the Hub API, Inference Providers, `git` and the Python libraries. The steps, from Hugging Face's [token docs](https://huggingface.co/docs/hub/security-tokens):

1. Create a free account at huggingface.co/join and sign in.
2. Open **Settings**, then the [Access Tokens](https://huggingface.co/settings/tokens) tab.
3. Click **New token**.
4. Pick a token type: **Fine-grained**, **Read** or **Write** (table below), and give it a name.
5. For a fine-grained token, tick only the permissions you need. To run models, tick **Make calls to Inference Providers**. To request access to a gated model through the API, tick **Request access to gated repos**.
6. Create the token, copy it into a password manager or an environment variable, and use it as `Authorization: Bearer hf_...`.

| Token type | What it can do | Use it for |
|---|---|---|
| Read | Read every public and private repo you can read, including your organizations' | Downloading private or gated models, Hub search, inference |
| Write | Everything Read can, plus push to repos you can write to | Uploading models, editing model cards, CI that publishes |
| Fine-grained | Only the permissions and repos you tick | Production apps; Hugging Face recommends fine-grained tokens for production |

Hugging Face recommends one token per app or machine, so you can revoke one without breaking the others. Delete or refresh a token from **Manage** on the same tab. If you find someone else's leaked token, `POST https://huggingface.co/api/credentials/revoke` invalidates it without any rights over the account, and always answers 202. In Team and Enterprise organizations, an admin can require approval for fine-grained tokens (a pending token cannot reach the organization's repos) or allow only fine-grained tokens, in which case read and write tokens get a 403 on that organization's resources.

From a terminal, `pip install huggingface_hub` and run `hf auth login`, which stores the token locally; `hf auth whoami` confirms which account it belongs to. Libraries such as `transformers` and `huggingface_hub` also read the `HF_TOKEN` environment variable.

## Hugging Face API pricing and free credits in November 2026

The Hub API is free; you pay only for compute. Inference Providers is pay-as-you-go: Hugging Face's [pricing doc](https://huggingface.co/docs/inference-providers/pricing) says it charges "the same rates as the provider, with no additional fees". What each plan includes:

| Account | Price | Monthly compute credits | Hub API rate limit (per 5 min) |
|---|---|---|---|
| Anonymous (per IP) | Free | None | 500 |
| Free account | Free | None; buy credits to use Inference Providers | 1,000 |
| PRO | $9 a month | $2.00 | 2,500 |
| Team | $20 per user a month | $2.00 per seat, shared | 3,000 per member |
| Enterprise | $50 per user a month | $2.00 per seat, shared | 6,000 per member |

Plan prices are from [huggingface.co/pricing](https://huggingface.co/pricing); credits from the pricing doc; rate limits from the [rate limits page](https://huggingface.co/docs/hub/rate-limits).

The free tier changed this autumn. An archived copy of the pricing doc from September 30, 2026 lists free users at "$0.10, subject to change"; the copy from October 19, 2026 and the live page now list "None". Guides that promise free accounts $0.10 a month, or a free serverless Inference API, describe the service before October 2026.

How the bill works:

- **Routed by Hugging Face** (the default): your HF token is charged at the provider's rate, and included credits apply first.
- **Custom provider key**: you save your own key for a provider in your [Inference Providers settings](https://huggingface.co/settings/inference-providers); the provider bills you directly and Hugging Face charges nothing, and your HF credits do not apply.
- **hf-inference**, Hugging Face's own provider (the old "Inference API (serverless)"), bills compute time times the hardware price. Hugging Face's example: a 10-second image request on a GPU costing $0.00012 a second is $0.0012. Hugging Face says that as of July 2025 it focuses mostly on CPU tasks such as embeddings and classification.
- **Credits are general compute credits** on PRO, Team and Enterprise: they also pay for Inference Endpoints, Spaces hardware and Jobs.
- **Team and Enterprise billing** goes to the organization when you send the header `X-HF-Bill-To: your-org` (or `bill_to=` in the Python client).
- **Live per-model prices** come from `GET https://router.huggingface.co/v1/models`, which needs no token. On November 15, 2026 it listed 133 chat models, each with its providers' status, context length, input and output prices, tool support and measured latency.

Spending is shown on your [billing page](https://huggingface.co/settings/billing), with a per-model and per-provider breakdown in the Inference Providers settings.

## Inference Endpoints and Spaces hardware prices

Inference Endpoints are dedicated, autoscaling deployments of one model, billed per minute while the endpoint is initializing or running, whether or not it gets requests. Hugging Face's [Endpoints pricing doc](https://huggingface.co/docs/inference-endpoints/support/pricing) says the service "is accessible to Hugging Face accounts with an active subscription and credits added". Selected hourly rates on AWS:

| Instance | GPU memory | Per hour | Per month (730 h) |
|---|---|---|---|
| CPU, Intel Sapphire Rapids x1 | 2 GB RAM | $0.033 | $24 |
| NVIDIA T4 x1 | 14 GB | $0.50 | $360 |
| NVIDIA L4 x1 | 24 GB | $0.80 | $576 |
| NVIDIA L40S x1 | 48 GB | $1.80 | $1,296 |
| NVIDIA A100 x1 | 80 GB | $2.50 | $1,800 |
| NVIDIA H100 x1 | 80 GB | $4.50 | $3,240 |
| NVIDIA H200 x1 | 141 GB | $5.00 | $3,600 |
| NVIDIA B200 x1 | 179 GB | $9.25 | $6,660 |

Scale-to-zero stops the bill when idle: by default an endpoint goes idle after 1 hour without traffic, schedules can set a timeout from 15 minutes to 12 hours, and the next request then waits through a cold start. Hugging Face's own worked example, a T4 with one replica that scales to three for 15 minutes every hour, comes to $547.50 a month.

Spaces run demos rather than APIs. CPU Basic (2 vCPU, 16 GB) and ZeroGPU are free; ZeroGPU gives every account a daily GPU quota, and PRO gets eight times the free quota (40 minutes a day) and can host up to 10 ZeroGPU Spaces. Paid Space hardware starts at $0.03 an hour for CPU Upgrade and $0.40 an hour for a T4.

## Hugging Face API endpoints

The Hub API's full reference is Hugging Face's [OpenAPI playground](https://huggingface.co/spaces/huggingface/openapi), with the spec at `https://huggingface.co/.well-known/openapi.json` (and a Markdown copy for agents at `/.well-known/openapi.md`). The endpoints most code needs:

| Endpoint | Returns | Token needed | Rate-limit bucket |
|---|---|---|---|
| `GET /api/models?search=&pipeline_tag=&sort=downloads&limit=` | Model list with id, downloads, likes, tags, license tag | No (yes for private) | api |
| `GET /api/models/{repo_id}` | One model: card data, files, gating, `sha`, last modified | No for public, ungated | api |
| `GET /api/models/{repo_id}?expand[]=inference` | Whether any provider serves it (`"warm"`) | No | api |
| `GET /api/models?inference_provider=all` | Models served by at least one inference provider | No | api |
| `GET /api/datasets?search=` and `/api/datasets/{repo_id}` | Datasets and their metadata | No | api |
| `GET /api/spaces?search=&filter=mcp-server` | Spaces, here those with the MCP badge | No | api |
| `GET /{repo_id}/resolve/{revision}/{path}` | Raw file download | Yes for gated or private | resolvers |
| `GET /api/whoami-v2` | The account behind a token | Yes | api |
| `POST https://router.huggingface.co/v1/chat/completions` | OpenAI-compatible chat completion | Yes, Inference Providers permission | billed per call |
| `GET https://router.huggingface.co/v1/models` | Chat models with provider prices and status | No | n/a |
| `POST https://router.huggingface.co/hf-inference/models/{repo_id}` | Task inference on Hugging Face's own provider | Yes | billed per call |

List endpoints page with a `Link: <...>; rel="next"` header holding a cursor; `huggingface_hub` follows it for you. On the router, the model id takes a suffix that picks the provider: `:fastest` (the default, highest throughput), `:cheapest` (lowest output-token price), `:preferred` (your order in settings), or a provider's name.

The old serverless host is gone. Calls to `api-inference.huggingface.co` returned HTTP 410 with "https://api-inference.huggingface.co is no longer supported. Please use https://router.huggingface.co/hf-inference instead." in November 2025, as quoted on the [Hugging Face forum](https://discuss.huggingface.co/t/169870), and on November 15, 2026 the hostname no longer resolved in DNS. Code that still uses it needs the router URL.

## Hugging Face API rate limits

Hugging Face counts requests in fixed 5-minute windows, in three buckets: Hub APIs, resolvers (file downloads through `/resolve/`) and web pages. The limits by plan, which the [rate limits page](https://huggingface.co/docs/hub/rate-limits) dates to September 2025:

| Plan | API | Resolvers | Pages |
|---|---|---|---|
| Anonymous (per IP) | 500 | 3,000 | 100 |
| Free account | 1,000 | 5,000 | 200 |
| PRO | 2,500 | 12,000 | 400 |
| Team organization | 3,000 | 20,000 | 400 |
| Enterprise organization | 6,000 | 50,000 | 600 |
| Enterprise Plus | 10,000 | 100,000 | 1,000 |

Anonymous and free limits "are subject to change over time depending on platform health". Organization limits apply to each member, not shared. Every response carries the IETF draft headers; an anonymous search on November 15 returned:

```text
RateLimit: "api";r=499;t=24
RateLimit-Policy: "fixed window";"api";q=500;w=300
```

`r` is requests left, `t` is seconds until the window resets, `q` is the quota and `w` the window in seconds. Over the limit you get HTTP 429. Hugging Face's first fix is to pass `HF_TOKEN` everywhere, since an unauthenticated script is limited per IP; after that, spread requests out, download files through resolvers instead of the API, or upgrade. `huggingface_hub` 1.2.0 and later reads the `RateLimit` header on a 429 and waits exactly that long before retrying. Repo creation, commits and discussion posts have their own limits, which Hugging Face does not publish.

## Python: search the Hub with huggingface_hub

This lists the top models, datasets and Spaces for a search and reads one model's license, gating and inference status. We ran it on November 15, 2026 with `huggingface_hub` 2.4.0 and no token; it made four API calls.

```python
import os

from huggingface_hub import HfApi

# A read token raises your Hub API limit from 500 to 1,000 requests per 5 minutes.
# Anonymous calls work for public repos; gated and private repos need a token.
api = HfApi(token=os.environ.get("HF_TOKEN"))

# Five most-downloaded text-generation models matching "qwen3"
for m in api.list_models(search="qwen3", pipeline_tag="text-generation",
                         sort="downloads", limit=5):
    print(f"{m.id:45} downloads={m.downloads:>12,} likes={m.likes}")

# One model's metadata: license, gating, and which inference providers serve it
info = api.model_info("Qwen/Qwen3-0.6B", expand=["cardData", "gated", "inference", "downloads"])
print(info.id, "license:", (info.card_data or {}).get("license"), "gated:", info.gated,
      "inference:", info.inference)

# Datasets and Spaces use the same pattern
for d in api.list_datasets(search="weather", sort="downloads", limit=3):
    print("dataset", d.id, d.downloads)
for s in api.list_spaces(search="transcribe", sort="likes", limit=3):
    print("space", s.id, s.likes)
```

The first lines it printed:

```text
Qwen/Qwen3-0.6B                               downloads=  17,792,207 likes=1902
Qwen/Qwen3-14B                                downloads=  13,049,351 likes=544
Qwen/Qwen3-8B                                 downloads=   6,050,582 likes=2188
Qwen/Qwen3-0.6B license: apache-2.0 gated: False inference: warm
```

Download counts change daily. The same searches work from the shell with `hf models ls --search llama --sort downloads --limit 5` and `hf models info <repo_id>`.

## Python: call a model through Inference Providers

This sends one chat completion through the router with `requests`, picks the cheapest provider for the model, and backs off on 429. It costs whatever the chosen provider charges for about 200 output tokens, billed to your Hugging Face credits.

```python
import os
import time

import requests

HF_TOKEN = os.environ["HF_TOKEN"]  # fine-grained, "Make calls to Inference Providers"
URL = "https://router.huggingface.co/v1/chat/completions"


def chat(prompt, model="openai/gpt-oss-120b:cheapest", retries=3):
    """One chat completion through Inference Providers, billed to your HF account."""
    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
    body = {"model": model, "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 200}
    for attempt in range(retries):
        resp = requests.post(URL, headers=headers, json=body, timeout=60)
        if resp.status_code == 429:
            time.sleep(2 ** attempt * 5)  # back off, then retry
            continue
        if resp.status_code != 200:
            raise RuntimeError(f"{resp.status_code}: {resp.text[:300]}")
        return resp.json()
    raise RuntimeError("Still rate limited after retries")


if __name__ == "__main__":
    out = chat("In one sentence, what is a model card?")
    print(out["model"], out["choices"][0]["message"]["content"])
    print("usage:", out.get("usage"))
```

The OpenAI SDK works the same way with `base_url="https://router.huggingface.co/v1"` and `api_key=os.environ["HF_TOKEN"]`. Hugging Face's own client picks the provider and formats the request for you:

```python
from huggingface_hub import InferenceClient

client = InferenceClient()  # reads HF_TOKEN
completion = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "How many 'G's in 'huggingface'?"}],
)
print(completion.choices[0].message)
```

## Hugging Face API errors and fixes

Hugging Face returns most API errors as JSON with the message repeated in an `X-Error-Message` header, and file downloads as plain text with an `X-Error-Code` header. With no token or a wrong one, the Hub API and the router (when a token is sent) returned exactly this on November 15, 2026:

```json
{"error":"Invalid username or password."}
```

An anonymous download from a gated model returned HTTP 401, `Content-Type: text/plain`, header `X-Error-Code: GatedRepo`, and this body:

```text
Access to model meta-llama/Llama-3.1-8B is restricted. You must have access to it and be authenticated to access it. Please log in.
```

| Status and message | Cause | Fix |
|---|---|---|
| 401 `{"error":"Invalid username or password."}` | Missing, mistyped or deleted token | Send `Authorization: Bearer hf_...`; check with `hf auth whoami` |
| 401 on `/api/models/{id}` for a repo you expect to exist | The repo is private or does not exist; anonymous callers get the same 401 for both | Check the id; send a token that can read the private repo |
| 401 HTML page "Unauthorized access" from the router | No `Authorization` header at all | Add the header |
| 401 `X-Error-Code: GatedRepo` | Gated model, no token or a bad one | Log in, request access on the model page, send a token |
| 403 "Access to model ... is restricted and you are not in the authorized list." | Valid token, but access not granted yet (manual approval pending) or rejected | Request access on the model page and wait; a rejected user cannot request again |
| 403 on an organization's repos | Token pending approval, denied, revoked, or not fine-grained where the org requires it | Ask the org admin; create a fine-grained token |
| 429 Too Many Requests | Over the 5-minute bucket for your plan | Wait `t` seconds from the `RateLimit` header; pass a token; upgrade |
| 402 Payment Required from the router | No credits left (forum reports since 2025; free accounts have no included credits) | Add credits on the billing page or subscribe to PRO |
| 410 or DNS failure on `api-inference.huggingface.co` | The legacy serverless host is retired | Use `router.huggingface.co/v1` or `/hf-inference/models/{id}` |

In Python, `huggingface_hub` raises `GatedRepoError`, `RepositoryNotFoundError` or `HfHubHTTPError` for these cases; we saw all three on November 15. The 401, gated and HTML bodies above are the ones we recorded; the 403 wording comes from the `huggingface_hub` [error reference](https://huggingface.co/docs/huggingface_hub/package_reference/utilities), and the 429 and 402 cases from Hugging Face's docs and forum, since they need an approved or funded account to observe.

## Hugging Face MCP server: setup for Claude, Claude Code, Cursor, VS Code and ChatGPT

Hugging Face runs an official remote MCP server at `https://huggingface.co/mcp` (short form hf.co/mcp), over streamable HTTP. It lets an assistant search and read models, datasets, Spaces, papers, collections and Hugging Face's documentation, and call Gradio apps hosted on Spaces as tools. The code is open source at [huggingface/hf-mcp-server](https://github.com/huggingface/hf-mcp-server) (MIT, 317 stars, last push November 10, 2026), and it is listed in the official MCP registry as `co.huggingface/hf-mcp-server`.

It works without an account. An anonymous `initialize` on November 15, 2026 returned server version 0.4.34 and four tools: `hf_fs` (browse and read the Hub, papers, docs and trending content), `hub_repo_search`, `hub_repo_details` and `hf_whoami`. Its instructions say anonymous use is rate limited and point to a token for higher limits. Signed in, you choose more tools at [huggingface.co/settings/mcp](https://huggingface.co/settings/mcp): **Contribute Repos** (create repos and write files), **Sandboxes**, and **Run and Manage Jobs** on Hugging Face hardware, plus any Spaces you add. There are two ways to sign in: OAuth in the browser through the `?login` URL, or a token in an `Authorization` header. A read token is enough for Hub and Space tools.

**Claude (claude.ai, Claude Desktop):** Hugging Face is in Claude's connector directory, made by Hugging Face and marked Anthropic verified. Open **Settings**, then **Connectors**, add **Hugging Face** from the directory, and sign in to Hugging Face when asked. The [directory listing](https://claude.com/connectors/hugging-face) uses `https://huggingface.co/mcp?login&gradio=none`.

**Claude Code**, signing in through the browser on first use:

```bash
claude mcp add hf-mcp-server -t http "https://huggingface.co/mcp?login"
```

or with a token:

```bash
claude mcp add hf-mcp-server -t http https://huggingface.co/mcp \
  -H "Authorization: Bearer YOUR_HF_TOKEN"
```

**Cursor** (`~/.cursor/mcp.json` or `.cursor/mcp.json` in a project):

```json
{
  "mcpServers": {
    "huggingface": {
      "url": "https://huggingface.co/mcp",
      "headers": { "Authorization": "Bearer YOUR_HF_TOKEN" }
    }
  }
}
```

For browser sign-in instead, drop `headers` and use `"url": "https://huggingface.co/mcp?login"`.

**VS Code** (`.vscode/mcp.json`), with the token asked for once and stored by VS Code rather than written in the file:

```json
{
  "inputs": [
    { "type": "promptString", "id": "hf-token", "description": "Hugging Face token", "password": true }
  ],
  "servers": {
    "huggingface": {
      "type": "http",
      "url": "https://huggingface.co/mcp",
      "headers": { "Authorization": "Bearer ${input:hf-token}" }
    }
  }
}
```

VS Code's MCP gallery also lists Hugging Face, which installs the `?login` URL with no file editing.

**ChatGPT:** Hugging Face's docs name ChatGPT among supported clients. In ChatGPT, open Plugins (chatgpt.com/plugins), select the plus button, choose **Add custom MCP server**, enter `https://huggingface.co/mcp?login` and pick OAuth, per [OpenAI's guide](https://developers.openai.com/api/docs/guides/developer-mode). Hugging Face's server publishes OAuth metadata with a dynamic client registration endpoint at `https://huggingface.co/.well-known/oauth-authorization-server`. The server README also documents `?bouquet=openai`, a tool set of Hub file browsing, repo search and details, repo creation, dynamic Spaces, Jobs and sandboxes.

**Running it locally** (STDIO, for clients that only launch local processes), from the README; the `@llmindset/hf-mcp-server` package was at 0.4.34 on npm on November 10, 2026:

```json
{
  "mcpServers": {
    "huggingface": {
      "command": "npx",
      "args": ["-y", "@llmindset/hf-mcp-server"],
      "env": { "HF_TOKEN": "YOUR_HF_TOKEN" }
    }
  }
}
```

Add `?no_image_content=true` to the URL to strip images returned by Gradio tools, for clients with limited image support. The Claude directory page still shows an older tool list (`model_search`, `paper_search`, `hf_doc_search` and others); the live server consolidated those into `hf_fs`, `hub_repo_search` and `hub_repo_details`.

Other servers in the MCP registry search for "huggingface" are third-party wrappers, several charging per query. The older community server [shreyaskarnik/huggingface-mcp-server](https://github.com/shreyaskarnik/huggingface-mcp-server) (72 stars) has had no push since March 2025; the official server covers what it did.

## Spaces as MCP servers with Gradio

Any public Gradio Space with the **MCP** badge can become a tool in your assistant without code. Browse [Spaces filtered by mcp-server](https://huggingface.co/spaces?filter=mcp-server), click the badge on one, choose **Add to MCP tools**, and it appears in your MCP settings and in every client connected to hf.co/mcp. With **Dynamic Spaces** turned on in those settings, the assistant can find and call MCP Spaces on its own. Calls to ZeroGPU Spaces spend your daily ZeroGPU quota.

Each such Space is also an MCP server by itself at `https://<owner>-<space>.hf.space/gradio_api/mcp/`; one we called on November 15 answered `initialize` with HTTP 200 over server-sent events. To build one, install `pip install "gradio[mcp]"` (Gradio was at 6.32.0 on PyPI that week) and launch with `mcp_server=True`. Gradio turns each function into a tool, using its name, type hints and docstring:

```python
import gradio as gr


def letter_counter(word: str, letter: str) -> int:
    """Count occurrences of a letter in a word.

    Args:
        word: The word to search in
        letter: The letter to count

    Returns:
        Number of times the letter appears in the word
    """
    return word.lower().count(letter.lower())


demo = gr.Interface(fn=letter_counter, inputs=["text", "text"], outputs="number")
demo.launch(mcp_server=True)  # MCP endpoint at /gradio_api/mcp/
```

Push it to a Gradio Space and it gets the MCP badge automatically.

## Choosing a route

The right route depends on whether you need Hub data, model output, or a tool inside an assistant.

- **Find models, datasets or Spaces and read their metadata:** the Hub API through `huggingface_hub`, free, 1,000 requests per 5 minutes with a free account's token.
- **Download weights to run yourself:** `/resolve/` through `huggingface_hub` or `transformers`, which has the highest limits; gated models need an approved account and a token.
- **Run an open model occasionally:** Inference Providers through the router; buy credits, or take PRO for $9 a month with $2 of credits included.
- **Steady production traffic on one model:** an Inference Endpoint, priced per minute by instance, with scale-to-zero for spiky use.
- **Let Claude, Cursor, VS Code or ChatGPT search the Hub:** the official MCP server at hf.co/mcp, anonymous to try, signed in for higher limits and extra tools.
- **Give an assistant a specific app (transcription, image generation):** add an MCP-badged Space, or build one with `gradio[mcp]`.
- **Cited research that draws on Hub metadata:** Hyperresearch reads Hugging Face Hub metadata (models, datasets and Spaces, with their cards, licences and download counts) as one of its 120+ [data sources](/sources).

For other MCP servers an assistant can use, see [MCP servers for research data](/guides/research-data-mcp-servers), [Claude Code as a research harness](/guides/claude-code-research-harness) and [how to add web search to an AI agent](/guides/add-web-search-to-ai-agent).

## Sources

- User access tokens: https://huggingface.co/docs/hub/security-tokens
- Hub rate limits: https://huggingface.co/docs/hub/rate-limits
- Hub API endpoints and OpenAPI spec: https://huggingface.co/docs/hub/api
- Gated models: https://huggingface.co/docs/hub/models-gated
- huggingface_hub errors (GatedRepoError example): https://huggingface.co/docs/huggingface_hub/package_reference/utilities
- Inference Providers: https://huggingface.co/docs/inference-providers/index
- Inference Providers pricing and billing: https://huggingface.co/docs/inference-providers/pricing
- Inference Providers pricing doc, archived September 30, 2026: http://web.archive.org/web/20260930051958/https://huggingface.co/docs/inference-providers/pricing
- Inference Providers pricing doc, archived October 19, 2026: http://web.archive.org/web/20261019082152/https://huggingface.co/docs/inference-providers/pricing
- Inference Providers Hub API: https://huggingface.co/docs/inference-providers/hub-api
- Inference Endpoints pricing: https://huggingface.co/docs/inference-endpoints/support/pricing
- Inference Endpoints autoscaling: https://huggingface.co/docs/inference-endpoints/guides/autoscaling
- Hugging Face pricing: https://huggingface.co/pricing
- Billing: https://huggingface.co/docs/hub/billing
- ZeroGPU: https://huggingface.co/docs/hub/spaces-zerogpu
- Search the Hub with huggingface_hub: https://huggingface.co/docs/huggingface_hub/guides/search
- huggingface_hub on PyPI: https://pypi.org/project/huggingface-hub/
- Hugging Face MCP server docs: https://huggingface.co/docs/hub/agents-mcp
- Spaces as MCP servers: https://huggingface.co/docs/hub/spaces-mcp-servers
- huggingface/hf-mcp-server README: https://github.com/huggingface/hf-mcp-server
- Building the Hugging Face MCP Server (July 10, 2025): https://huggingface.co/blog/building-hf-mcp
- Official MCP registry: https://registry.modelcontextprotocol.io/v0/servers?search=huggingface
- Claude connector directory, Hugging Face: https://claude.com/connectors/hugging-face
- Gradio, building an MCP server: https://www.gradio.app/guides/building-mcp-server-with-gradio
- OpenAI, Add custom MCP server: https://developers.openai.com/api/docs/guides/developer-mode
- VS Code MCP configuration reference: https://code.visualstudio.com/docs/agents/reference/mcp-configuration
- Hugging Face forum, api-inference.huggingface.co no longer supported (November 3, 2025): https://discuss.huggingface.co/t/169870
