Hugging Face adds DeepInfra to Inference Providers, running models through a single API

Hugging Face has added DeepInfra to its list of Inference Providers on the Hub. Developers can now run models available through DeepInfra directly from model pages, through the client SDKs, and via the unified Hugging Face router. None of this requires a separate custom integration.

What launched

The new integration expands the serverless inference ecosystem inside Hugging Face. DeepInfra is now a supported provider on the Hub, so developers can pick its models in the same place where they already browse datasets, model cards and ready-made code snippets. The announcement describes DeepInfra as an AI inference platform with more than 100 models and one of the lowest per-token prices on the market. For Hugging Face, this is another step toward a model where the Hub serves as a single launch point for models, not just a catalog.

At launch, the integration covers conversational use cases and standard text generation. Through DeepInfra on Hugging Face, developers can already call popular open-weight models such as DeepSeek V4, Kimi-K2.6 and GLM-5.1. The team has also outlined the next stage: text-to-image, text-to-video, embeddings and other task types are expected to arrive through the same layer in the future. In other words, this isn't a one-off integration of one or two LLMs. It connects a broader compute channel to Hugging Face's infrastructure.

How it works

For users, everything is built into the familiar Hub interface. In account settings, you can add your own provider keys and set an order of preference. On model pages, Hugging Face lists compatible external providers and generates widgets and code samples for them. If no key is set, requests can go through Hugging Face itself. If you have a key, calls go directly to DeepInfra. This removes extra manual setup and makes switching between providers noticeably easier.

• Your own DeepInfra API key for direct calls with no intermediary
• A "routed by HF" mode that doesn't require a separate provider key
• Provider sorting based on user-defined priority
• The same approach across the Hub interface, Python SDK and JavaScript SDK
• Connection to popular agent harnesses without extra glue code

The setup is just as simple in code. DeepInfra is available through `huggingface_hub` for Python and `@huggingface/inference` for JavaScript. The examples in the announcement use an OpenAI-compatible client with the base URL `https://router.huggingface.co/v1` and a Hugging Face token. You specify the model in `model:provider` format — for example, to call DeepSeek through DeepInfra. The announcement also points out that the integration already works in a number of agent harnesses, so developers can plug the models into agent tooling on top of the shared API, not just into raw code.

Pricing and access

Hugging Face has kept billing to two straightforward scenarios. If a developer uses their own DeepInfra key, DeepInfra bills them at its own rates. If a request is routed through the Hugging Face Hub, the charge goes to the Hugging Face account, but the platform adds no markup: the company says it simply passes through the provider's standard API cost. That matters for teams, because the unified router doesn't become yet another pricing layer on top of existing infrastructure.

There's also an easy way to test the integration without spending much. PRO subscribers get $2 in inference credits per month, which they can spend across different providers in the system. Free accounts also get a small inference allowance, though Hugging Face openly nudges active users toward PRO. In practice, this lowers the barrier to entry: you can quickly compare DeepInfra against other providers on the same models without building a separate test bench or configuring several different SDKs.

What it means

Hugging Face is increasingly turning the Hub into an orchestration layer across multiple AI providers rather than just a model showcase. For developers, that means less manual integration, faster testing of open-weight LLMs, and a simpler path to a multi-provider architecture without rewriting client code.