Hugging Face API is the model inference service layer provided by the Hugging Face platform, including free Inference API (Serverless on-demand inference) and paid Inference Endpoints (dedicated GPU endpoints). Users do not need to manage the underlying infrastructure, and can call 100,000+ open source models through the REST API for tasks such as text generation, image generation, speech recognition, and embedding.

Core parameters and statistics of Hugging Face API

Hugging Face API is not an independent product, but the model inference service layer of the Hugging Face platform for developers. It contains two core product lines: Inference API (free Serverless inference) and Inference Endpoints (paid dedicated GPU endpoints). Inference Providers (third-party supplier routing layer) will be added in 2025. The three constitute a complete inference service system.

Dimensions	Key facts
Official positioning	Hosted inference service of open source model, Serverless + dedicated endpoint dual mode
Service model	Inference API (free/pay as you go), Inference Endpoints (per GPU hour), Inference Providers (per call)
Callable models	100,000+ Hub models (Inference API supports about 200+ selected models)
Supported modalities	Text, image, audio, video, multimodal, embedding vector
Underlying GPU	CPU / T4 / A10G / A100 / H100 (different from Tier according to service mode)
Maximum context	Depends on selected model, non-API layer limit
Rate Limits	Free Tier: 30 requests/minute; PRO: Undisclosed; Endpoints: Unlimited (depends on instance size)
SLA	Inference API: Best-effort; Inference Endpoints: Depends on selected GPU instance and enterprise contract
Compliance certification	Enterprise plan supports SOC2, GDPR, private deployment

Parameter Interpretation: The core differentiation of Hugging Face API lies in "model selection" - users do not select endpoints from a fixed API list, but freely choose from the entire Hub model ecosystem. Inference API provides a "try before you buy" experience, and you can call mainstream models with zero configuration; Inference Endpoints solves the last mile of "from experiment to production", allowing the same model to be converted from Spaces Demo to production API with one click. This smooth transition path of "try → use → scale" is the key difference between it and pure inference platforms such as Replicate and Together AI.

Platform Boundary: The Hugging Face API does not provide model training or fine-tuning capabilities (AutoTrain is a separate service), nor does it promise a free tier availability SLA. It is most suitable for scenarios where "the model has been selected and needs to be quickly launched for inference", but not suitable for scenarios where "customized training is required before deployment" or "extreme requirements on latency".

User and market recognition of Hugging Face API

The user base of Hugging Face API is deeply bound to the community scale of Hugging Face platform, and its market recognition can be observed from three levels:

Community penetration rate: The Hugging Face platform has millions of monthly active developers, and the Inference API serves as the platform’s native inference entrance and handles hundreds of millions of requests per day. Since all model card pages have a built-in "Hosted Inference API" one-click trial button, users don't even need to actively search for API documentation to trigger the first inference call - this "zero friction" embedding method is the core engine for API user growth.

Enterprise customer coverage: Inference Endpoints’ enterprise customers include leading companies in finance, medical, technology and other industries. Compared with directly using cloud vendor GPU instances, the selling point of Inference Endpoints is "operation-free" - automatically handling model loading, expansion and contraction, health check and fault recovery. According to official information released by Hugging Face, more than 50% of employees in the world's top 500 companies are using the Hugging Face platform, and a considerable proportion of inference traffic is carried through Endpoints.

Third-party ecological integration: Hugging Face API is integrated as the default inference backend by many mainstream AI application frameworks and platforms, including LangChain (through HuggingFacePipeline / HuggingFaceEndpoint), LlamaIndex, Haystack, and the default inference interface of Gradio. This "framework-level integration" means that developers will almost certainly come into contact with the Hugging Face API when using these tools.

Market Benchmarking: In the field of open source model inference services, Hugging Face API’s direct competitors include Replicate (more focused on the creator community), Together AI (more focused on high-performance reasoning), Fireworks (focusing on low latency), and model hosting services from major cloud vendors. The differentiating advantage of Hugging Face lies in the breadth of the model ecosystem - other platforms select dozens to hundreds of models, while the Hugging Face API can call any model on the Hub (after the developer manually configures Endpoints). This "long-tail coverage" capability is irreplaceable in scenarios that require niche models.

The cost advantage of Hugging Face API: three-layer inference architecture, progressive payment based on usage depth

The cost structure of Hugging Face API is not a single dimension, but a progressive payment path is designed in three stages: "Trial → Stability → Scale". The following comparison table presents the cost differences between the three product lines:

Dimensions	Inference API (Free)	Inference API (PRO by volume)	Inference Endpoints	Inference Providers
Paid model	Free quota	Pre-recharge + billing by call volume	Billed by GPU hour	Billed by call volume
GPU Resources	Shared CPU/GPU, queued scheduling	Shared GPU, priority over free	Dedicated GPU instances	Third-party vendor GPUs
Applicable scale	Prototype verification, personal experiments	Light-weight production, personal projects	Stable production load	Large-scale reasoning, cost optimization
Cold start	Yes (the model needs to be loaded for the first call)	Yes (same as free)	No (instance is resident)	Depends on the supplier
SLA	None (Best-effort)	None (Best-effort)	Yes (depends on contract)	Depends on supplier
Price Range	$0	~$0.0001–$0.01/call	$0.50–$5.00+/GPU hour	$0.0001–$0.02/call

C client/individual users: The free Inference API covers most learning, prototype verification and lightweight experiment scenarios. The real limitation is not the quota, but the "uncertainty" - the queuing time of the shared GPU is unpredictable, the first call needs to wait for the model to be loaded into the memory (a cold start may take up to tens of seconds), and the list of available models is maintained by HF, and custom models are not supported. For scenarios where "as long as it can run", the free tier has a very low entry threshold; for scenarios where "stable response time is required", you need to upgrade to a paid plan.

Developers/API users: Inference API’s PRO plan provides higher rate limits and priority scheduling, and the billing method is deducted according to the call volume after pre-recharge. The cost of Inference Endpoints depends on the selected GPU model (T4 ~$0.50/hour A100 ~$3.50/hour H100 ~$5.00/hour+) and run time, and supports automatic hibernation to save idle costs. There is an implicit cost here: from "selecting a model" to "configuring Endpoints to achieve production stability", you need to go through model compatibility verification, concurrency stress testing, automatic scaling policy tuning and other investments. These labor costs are often much higher than the GPU instance fee itself.

Enterprise/Private Users: The Enterprise plan involves VPC deployment of private Hub instances, security audits and compliance certifications. The price is subject to business confirmation. Before purchasing, enterprises need to confirm: ① Whether Endpoints supports deployment in the enterprise VPC (private network traffic does not go through the public network); ② Whether the retention period and export format of audit logs meet compliance requirements; ③ Whether there is a dedicated support team and SLA compensation terms.

Main functions of Hugging Face API

The functions of Hugging Face API revolve around the core task of "model inference", but different service models have significant differences in depth of capabilities.

• Serverless Inference (Inference API): Call 200+ selected models through a single REST endpoint, supporting tasks such as text classification, question and answer, summarization, translation, text mapping, speech recognition, embedding and other tasks. Core Value: Zero-configuration startup - no need to select a GPU model, configure an inference framework, or manage expansion and contraction. Inference can be completed with a single POST request.

• Inference Endpoints: Deploy any Hub model as a production-grade REST API, supporting custom container images, auto-scaling, multi-region deployment, health check and automatic recovery. Collaboration with Inference API: After verifying the model effect on the Inference API, switch to Endpoints mode with one click. The URL and interface protocol remain unchanged, and only the underlying resource model is changed - switching from a shared queue to an exclusive instance.

• Inference Providers routing layer: Unified access to multiple third-party GPU providers such as Together, Replicate, Fal, Cerebras, Fireworks, etc., through unified API calls. Hidden linkage: Deep integration of Providers and Model Cards - "Use with Inference Providers" can be directly selected on the model card. Model selection and computing power selection are decoupled, and users can switch providers to optimize costs or delays without switching API clients.

• Batch inference and asynchronous tasks: Inference Endpoints supports asynchronous inference mode (polling the results after sending the request), which is suitable for processing long text or large batch tasks. Works with the Tasks API to implement queuing, callback notifications, and result persistence.

• Custom Transformers code inference: Advanced users can run custom inference code on Endpoints (via a custom Docker image), not limited to the implementation of the HF official pipeline. Applicable scenarios: Complex scenarios that require loading of a custom tokenizer, multiple post-processing logic, or multiple models that need to be concatenated into a single inference endpoint.

• Embedding vector service: Call popular embedding models such as sentence-transformers and text-embeddings-inference through a unified text embedding API to support batch text vectorization. Collaborative scenario: Used in conjunction with vector databases such as Chroma, Pinecone to build an embedded node for the RAG pipeline.

• Task API task routing: Different model architectures correspond to different task endpoints (/v1/chat/completions is used for dialogue models, /v1/embeddings is used for embedding models, /v1/audio/speech is used for speech synthesis, etc.), and the interface style gradually evolves towards OpenAI API compatibility.

Model and version evolution of Hugging Face API

The version evolution of Hugging Face API is marked by "service model expansion" rather than traditional version number iteration. The following is a timeline of key milestones:

Milestones	Time	Focus of changes	Impact on developers
Released by Inference Providers	2025-01	Unified third-party supplier inference interface	Model and computing power are decoupled, developers can switch across suppliers to optimize costs
Inference Endpoints v2	2024-06	Auto-scaling, multi-region deployment, custom containers	Production-level deployment capabilities have been greatly improved, supporting enterprise-level traffic patterns
Inference API public beta	~2022-09	Free Serverless inference is online	Zero threshold for calling open source models, community adoption rate is rising rapidly
Inference Endpoints first release	~2022-03	Paid GPU endpoint service launched	The first mile from demo to production
Popularization period of Transformers library	2018–2021	Unified model standard interface	The calling protocol of the API layer is directly inherited from the pipeline interface of Transformers

Version context description: The evolution of Hugging Face API is closely coupled with the development of the entire Hugging Face platform. In the early days (before 2022), developers mainly provided inference services externally by deploying Transformers on their own servers or through Gradio Spaces. The launch of the Inference API simplifies the "using model" operation from "download code → configure context → start service" to a single HTTP request. Inference Endpoints further fills the gap in production scenarios where "multiple people are concurrent and SLA is required". Inference Providers in 2025 represents the third stage - from "self-built inference" to "inference routing", and the role of the platform evolves from a computing power provider to a computing power middle layer.

Technical advantages of Hugging Face API

The technical advantage of Hugging Face API does not lie in the leadership of a single indicator, but in the combined effect of "model ecology × deployment flexibility × API compatibility". Expand according to the "Mechanism → Effect → Applicable Scenario" structure:

Mechanism → Effect → Applicable Scenarios:

• Cold start optimization for model loading: The Inference API uses a shared cache pool to reduce model loading time. When a model is called frequently, its weights are kept in memory, and subsequent requests directly hit the cache. The effect is that the response time of popular models is much lower than that of less popular models. The applicable scenario is "call pattern concentrated" applications - if the user group is concentrated in a few head models, the actual performance of the Inference API may be close to that of a dedicated endpoint.

• Automatic Scaling and Idle Recycling: Inference Endpoints supports automatic expansion and contraction based on request volume, and automatically sleeps when there is no traffic to save costs. The first request after hibernation requires about 10–30 seconds of cold start time (depending on model size). The effect is to achieve a dynamic balance between "cost" and "response speed". The applicable scenario is a production environment with obvious peaks and troughs in traffic - such as customer service robots with high frequency during the day and low load at night.

• Customized inference container: Inference Endpoints allows users to upload custom Docker images and fully control the inference stack (including Python dependencies, system libraries, and model loading logic). The effect is to eliminate the compatibility risk of "the platform inference stack does not support special implementation of the model". Applicable scenarios are scenarios that use non-standard model architectures (such as Mamba, RWKV) or require complex pre-processing/post-processing.

• Inference performance and throughput: Hugging Face API does not disclose the specific TTFT (first word delay) and TPM/RPM (Tokens/requests per minute) upper limit of each model, because these indicators are highly dependent on the selected GPU model, concurrency number, and model architecture. Typical reference values ​​provided by official documents: deploy Llama-3.1-8B with vLLM on A100, single instance throughput is about 2000–4000 tokens/s (input length 2048 scenario). Actual performance requires users to conduct stress testing according to their own models and loads. Adaptation boundary: Hugging Face API is good at rapid deployment and invocation of medium-scale (<70B parameters) models, but not good at extreme inference optimization of very large-scale models (at this time, dedicated inference engines such as , Fireworks AI and other dedicated inference engines may have better P50/P99 latency performance).

• Disaster-tolerant design for multi-vendor routing: Inference Providers implement a layer of transparent routing at the call level - when a supplier fails or responds too slowly, requests can be automatically forwarded to the same model of other suppliers. The effect is to improve the overall availability of the inference layer, without requiring the application layer to perform failover logic. The applicable scenarios are medium and large applications that have high availability requirements but do not want to be bound to a single cloud vendor.

How to use Hugging Face API

Hugging Face API provides a multi-level usage path from zero configuration to complete self-control:

Entrance	Adaptable Crowd	Key Capabilities	Cost
huggingface.co Model Page (Web)	All users	Try out inference directly on the model card, no API Key required	Free
Inference API (Serverless)	Developer	Call 200+ featured models via REST API	Free / Pay-as-you-go
Inference Endpoints	Developer / DevOps	Deploy any Hub model to a production API with one click	Pay per GPU hour
Inference Providers	Developers	Unified API calls to multiple third-party GPU vendors	Pay per call
Hugging Face JS/Python SDK	Developer	Called via huggingface_hub / @huggingface/inference	SDK free, API pay-per-use

Typical workflow link:

1. Filter candidate models by model card or task type on the Hub
2. Directly test run inference in the "Hosted Inference API" widget on the model page (no API Key required, no need to write code)
3. After confirming the model effect, obtain the HF Token and call it in the code through the Inference API
4. If the traffic is stable, create an Inference Endpoint and switch to an exclusive GPU instance.
5. If you need to compare costs from multiple suppliers, switch the computing power source through the Inference Providers unified interface.

API call example (Python - Inference API):

import requests

API_URL = "https://api-inference.huggingface.co/models/meta-llama/Llama-3.1-8B-Instruct"
headers = {"Authorization": "Bearer <YOUR_HF_TOKEN>"}

payload = {
    "inputs": "What are the advantages and disadvantages of Hugging Face API compared with Replicate?",
    "parameters": {
        "temperature": 0.7,
        "max_new_tokens": 512,
        "top_p": 0.95,
        "do_sample": True
    }
}

response = requests.post(API_URL, headers=headers, json=payload)
print(response.json())

API call example (cURL - OpenAI compatibility mode):

curl https://api-inference.huggingface.co/v1/chat/completions \
  -H "Authorization: Bearer <YOUR_HF_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/Llama-3.1-8B-Instruct",
    "messages": [
      {"role": "user", "content": "Introduce the service model of Hugging Face API"}
    ],
    "temperature": 0.7,
    "max_tokens": 512,
    "stream": true
  }'

Note: <YOUR_HF_TOKEN> needs to be generated in the Settings → Access Tokens page of the Hugging Face account. The list of available models for the Inference API is based on the official API documentation. Streaming responses (stream: true) require the client to parse Server-Sent Events chunk by chunk. Inference Endpoints are created and configured in the Hugging Face Web UI and support selected GPU models, number of replicas, autoscaling policies, and regions.

Product Pricing for Hugging Face API

The pricing model is subject to the official real-time page. Usually a freemium or subscription system is used, and basic functions can be used for free. Advanced functions or high-frequency use require paid subscriptions, and users are advised to evaluate the optimal solution based on actual usage.

Application scenarios of Hugging Face API

The implementation scenario of Hugging Face API covers the entire link from "model selection and verification" to "production-scale inference". The choice of API service mode is also different at different stages:

• Model selection and effect verification: After screening candidate models on the Hub, directly enter test samples into the Hosted Inference API control on the model page to compare the output quality of different models. Implementation benefits: Compress the model selection cycle from "a few days (read the paper → find the weights → build a context → run inference)" to "a few minutes (click the test directly on the model page)". Suitable stage: Technical research and model preliminary screening during the project start-up period.

• Lightweight Prototyping and MVP Building: Integrate open source models into your app backend in hours using the Inference API free tier or PRO plan. Typical tasks: text classification (customer service ticket marking), named entity recognition (resume information extraction), text embedding (vectorization of RAG retrieval). Inference comparison: The traditional method requires building an inference service by yourself, which takes about 2–5 days; using the Inference API shortens it to 2–4 hours—provided that the model is selected and the input and output are clearly defined.

• Production-level inference deployment: After the prototype verification passes and the traffic is stable, switch from "trial mode" to "production mode" with one click through Inference Endpoints. Key configuration: Select the GPU model, set the number of replicas and auto-scaling policy, and configure the idle sleep time. Acceptance focus: Whether the measured P50/P99 delay meets the business requirements; whether the trigger conditions and response speed of automatic scaling comply with the traffic fluctuation pattern; whether the cold start delay is within the acceptable range.

• Multi-supplier cost optimization: For large-scale inference scenarios with more than one million daily calls, use Inference Providers to compare the prices and delays of multiple suppliers and dynamically switch to optimize overall costs. Requirements: The volume of calls is large enough for price differences between providers to be significant (monthly call charges $1000+), and sensitivity to latency allows for slight variations when switching between providers.

• Embeddings with knots for RAG pipeline: In the Retrieval Augmented Generation (RAG) architecture, text vectors are computed in batches using the embeddings endpoint of the Inference API (/v1/embeddings). Collaborative value: Cooperate with Datasets Hub and Vector Database to form a complete pipeline of "document → embedding → storage → retrieval", and the embedding service and the conversational reasoning service share the same API Key and authentication system.

• Education and Training: Teaching packages for universities and corporate training institutions using the Inference API - students do not need to configure a GPU environment and can directly experience the difference in capabilities of different models through API calls. Prerequisite: The free tier may encounter rate limitations in concurrent class calling scenarios. It is recommended for educational purposes to contact HF to apply for an education plan or use a personal PRO account.

Applicable groups of Hugging Face API

The service model of Hugging Face API covers a wide range of needs from "just want to try the model" to "requiring production-level inference SLA", but the depth of adaptation varies significantly among different groups of people:

• Individual Developers & Independent Hobbyists: The free tier of the Inference API is the best starting point for "exploring AI models at zero cost". Typical path: Complete a side project by calling the model through requests.post in Notebook. There is no need to pay for up to thousands of monthly calls. Prerequisite: Have basic knowledge of HTTP and JSON, and be able to handle unstructured responses returned by the API.

• Startup Teams and Small Micro Projects: Inference API PRO or small Endpoints provide a smooth transition path from prototype to early users. Cost deduction: For a chatbot with 1,000 daily calls, using the Inference API PRO of Llama-3.1-8B, the monthly calling fee is about $30–60; after switching to T4 Endpoints, the monthly fee is about $150–300 (including idle sleep). Boundary Tip: When call volume continues to grow, you should consider signing a reservation contract with a cloud GPU vendor or using Inference Providers for bidding optimization.

• Enterprise ML teams and AI applications: Inference Endpoints is the standard solution for enterprise-level inference deployment. Suitable scenarios: Internal tools, customer-facing functional modules, AI components in data pipelines. Not suitable for scenarios: Real-time online services with extreme latency requirements (such as search sorting returned within 100ms), in which case a dedicated inference engine (such as TensorRT-LLM, vLLM or optimization platforms such as Fireworks/Together) may be more suitable.

• Data Scientists and Researchers: The Inference API is used to quickly verify the performance of models on their own data, without the need for IT support. Typical use: In the Notebook environment of Hugging Face Spaces, test the output differences of different models on the same data through API calls. Prerequisite: The amount of data should not be too large (there is an input length limit for a single request in the free tier). It is recommended to use the local or Endpoints solution for large-scale evaluation.

• Unsuitable people: ① Developers who need standardized OpenAI API compatible interfaces and do not want to make any adaptations - although HF has begun to migrate to OpenAI compatible formats, the coverage is still improving; ② Organizations that attach great importance to data privacy and are unwilling to bear any network transmission risks - Inference API and Endpoints are on the public network by default, and enterprise VPC deployment requires the Enterprise plan and requires additional network configuration; ③ The amount of calls is extremely small (monthly calls <100 times) - At this time, it may be more convenient to interact directly with the free demo on Hugging Face Spaces than to call the API.

Summary and Outlook

The core competitiveness of Hugging Face API lies in the combination of "the width of the model ecosystem × the gradient of the service model × the zero-friction entry experience". As an open source model inference service layer, it allows developers to smoothly transition from "click on the model page to try" to "production-grade dedicated GPU endpoints" without managing any infrastructure. This continuous experience of "from trial to use" is the most differentiated value proposition in the current reasoning service market.

Current Limitations and Uncertainties:

1. Uncontrollable latency and performance: The shared queue mode of the Inference API means large fluctuations in latency. Even if you switch to Inference Endpoints, the delay changes caused by cold start and automatic scaling require fault-tolerant design at the application layer. For latency-sensitive online services, it is still currently recommended to use a dedicated inference engine or deploy vLLM/TGI self-hosted directly.

2. API compatibility transition period: Hugging Face API is migrating from a custom REST interface to an OpenAI compatible format, but it is currently in a "dual-track" stage - some endpoints support the OpenAI format, and some endpoints still use the HF native interface. This inconsistency brings additional adaptation work to developers, and it is expected that it will take several quarters of iterations to complete the unification.

3. Potential conflicts between self-owned models and commercialization: As HF releases more self-developed models, its positioning as a "neutral inference market" may be questioned. Although the design idea of ​​Inference Providers is to maintain supplier neutrality, whether the platform will give priority to recommending its own models or giving its own services better pricing and scheduling strategies is something that enterprise users need to continue to observe in long-term cooperation.

4. Coopetition with cloud vendors: Inference Endpoints is essentially a layer of management services running on GPU instances of cloud vendors (AWS, Azure, GCP). As cloud vendors launch their own model hosting services (such as AWS Bedrock, GCP Vertex AI Model Garden), Hugging Face API needs to continue to prove the value of "one more layer of abstraction" - that is, whether the model management, autoscaling, health checking and multi-vendor routing provided by the platform are worth the cost of the additional abstraction layer.

Procurement and Adoption Risk Assessment: For teams that "need to quickly launch open source model inference", the Hugging Face API has an extremely low threshold and controllable risks - start with the free tier to verify the model effect, and then upgrade to the paid plan after confirmation. The recommended adoption path is "Free Inference API verification → PRO light production → Endpoints stable load", and each step has a clear exit and migration path. Enterprises need to focus on verification before purchasing: ① Whether the VPC deployment plan of the Enterprise solution meets the data compliance requirements; ② Whether the supplier list of Inference Providers has options that meet the business area coverage; ③ Confirm the specific coverage of the SLA compensation clause at the contract level (usually only the infrastructure availability of Endpoints is guaranteed, and the specific percentile value of inference delay is not guaranteed).

Hugging Face API version evolution supplement

Inference service expansion context

Time	Service evolution	Impact on users
2025-01	Inference Providers goes online	Model and computing power are decoupled, making cross-supplier cost optimization possible
2024-Q2	Endpoints automatic scaling + custom containers	Mature production-level deployment capabilities, accelerated enterprise adoption
~2023	Endpoints supports multi-region deployment	Latency optimization of global applications becomes possible
~2022-09	Inference API public beta	Free Serverless inference lowers the entry barrier
~2022-03	Inference Endpoints first release	From community demo to commercial inference service
~2021	Gradio/Streamlit Spaces goes online	Accumulate model assets for Inference API that can be tried immediately

API Compatibility Evolution

The interface protocol of Hugging Face API has gone through three major iterations: in the early stage, a custom REST protocol (based on task type routing of the Transformers pipeline) was adopted; in the mid-term, the tasks endpoint was introduced to standardize the request format of different model types; in 2024, OpenAI-compatible /v1/chat/completions and /v1/embeddings endpoints will be provided to reduce the switching cost of migrating from closed-source APIs. As of Q2 2026, mainstream chat models and embedding models have supported OpenAI compatible formats, but some special tasks still require the use of HF native interfaces. Developers should check the API documentation of the corresponding model to confirm the available endpoints before use.

Comparison of competing products

Comparison dimensions	The tool	Competitor A	Competitor B
Core Differences	—	—	—
Price	—	—	—
Target User	—	—	--

Core parameters and statistics of Hugging Face API

Specific technical parameters (such as model size, context length, supported file formats, input and output restrictions, etc.) are subject to the official product page. It is recommended that users verify the latest technical specifications and system requirements before choosing to ensure that they match their own usage scenarios.

How to use Hugging Face API

• Web client: You can use it by visiting the official website and registering an account. Most functions do not require installation.
• API access: Provides RESTful API, developers can obtain the API Key and integrate it into their own applications.

Version Info

• Inference Providers ：Inference Providers are launched, allowing any model card to uniformly call multiple inference providers such as Together, Replicate, Fal, Cerebras, etc., and charge per call. Form a three-layer reasoning service system with Inference API/Inference Endpoints. （2025-01-28）
• Inference Endpoints v2 ：A major update to Inference Endpoints, supporting Auto Scaling, multi-region deployment, custom container images, and more fine-grained GPU model selection (A10G, A100, H100). There is no official precise date yet. （2024-06-15）
• Inference API public beta ：Hugging Face launches a free Inference API that allows developers to directly call popular models on the Hub through REST requests without the need for self-deployment. Initial support for 30+ models. There is no official precise date yet. （~2022-09）
• Posted by Inference Endpoints ：Hugging Face launches Inference Endpoints paid service, which supports one-click deployment of Hub models into production-grade REST APIs and is billed by GPU hours. There is no official precise date yet. （~2022-03）