Resumo rápido (agosto de 2026): O Hugging Face é a plataforma central de IA open, com mais de 2 milhões de checkpoints de modelos, 500,000+ datasets e mais de 1 milhão de apps interativos de demonstração chamados Spaces. Você pode testar qualquer modelo público no navegador sem precisar configurar nada, chamar modelos de forma programática por meio de um único token que roteia para 18 parceiros de computação de inferência, ou baixar e executar modelos localmente com a biblioteca Python transformers. Uma conta gratuita cobre a maior parte da experimentação, incluindo cinco minutos de GPU por dia pelo ZeroGPU; o plano PRO custa $9/month; os planos organizacionais Team e Enterprise começam em $20 e $50 por usuário por mês, respectivamente, com computação cobrada separadamente em todos os planos.

Última verificação: August 31, 2026, com base nos documentos e páginas de preços oficiais.

O Que é o Hugging Face

O Hugging Face é uma plataforma, uma comunidade e um ecossistema de bibliotecas. O componente central é o Hub em huggingface.co: um host de repositórios baseado em Git, projetado para artefatos de IA. Cada modelo, dataset e Space é um repositório com controle de versão, histórico de commits, branches, pull requests e threads de discussão. Os repositórios usam o Xet, uma camada de armazenamento para arquivos grandes que desduplicata blocos entre uploads e acelera as transferências.

A plataforma é neutra em relação a famílias de modelos. Você encontra checkpoints de Meta, Google, Microsoft, Mistral, DeepSeek, EleutherAI e milhares de colaboradores independentes. As licenças variam: muitos modelos populares são Apache 2.0 e podem ser usados comercialmente; outros restringem o uso comercial ou exigem que você envie uma solicitação de acesso e concorde com os termos antes de baixar.

Três sistemas interconectados formam a plataforma:

• O Hub: repositórios com controle de versão para modelos, datasets e Spaces, cada um com visualizadores no navegador e widgets de inferência ao vivo
• Inference Providers: um roteador de API serverless que envia sua solicitação para um dos 18 parceiros de computação (Groq, Together AI, Cerebras, Replicate, fal.ai e outros) usando um único token do Hugging Face
• A biblioteca transformers: uma biblioteca Python com mais de 164,000 estrelas no GitHub para carregar qualquer modelo do Hub e executá-lo no seu próprio hardware

Configure Sua Conta e Obtenha um Token

Crie uma conta gratuita em huggingface.co. Não é necessário cartão de crédito. Após fazer login, acesse Settings > Access Tokens para criar um token de API.

Para o Inference Providers (a API serverless), gere um token de granularidade fina com a permissão "Make calls to Inference Providers" habilitada. Para fazer upload de modelos ou ler repositórios privados, um token padrão de leitura/gravação funciona.

Para autenticar pelo terminal, instale a CLI e faça login:

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 solicita seu token e o armazena em ~/.cache/huggingface/token. Depois disso, todas as bibliotecas do HF leem automaticamente desse cache. Em ambientes de CI/CD e Docker, defina a variável de ambiente HF_TOKEN diretamente em vez de usar o comando de login.

Encontre e Teste Modelos Sem Escrever Código

O navegador de modelos em huggingface.co/models permite filtrar por tarefa, biblioteca, idioma, dataset e licença. Filtros de tarefas comuns:

• text-generation para grandes modelos de linguagem
• automatic-speech-recognition para transcrição (Whisper e variantes)
• text-to-image para modelos de difusão
• feature-extraction para modelos de embedding usados em buscas e RAG

Cada página de modelo inclui um Model Card com uso pretendido, limitações conhecidas, dados de treinamento e resultados de avaliação. Abaixo do card há um widget de inferência ao vivo, alimentado pelo Inference Providers: digite um prompt e receba uma resposta diretamente na página, sem escrever código.

Para comparar modelos de chat lado a lado, o Inference Playground em huggingface.co/playground permite executar o mesmo prompt em vários modelos simultaneamente.

Modelos com acesso restrito (Llama, Gemma e outros) exibem um botão de solicitação de acesso no topo da página do modelo. Você precisa enviar uma solicitação e concordar com os termos de licença antes de baixar os pesos ou chamar o modelo via API. A aprovação costuma ser automática e quase instantânea para a maioria das variantes do Llama.

Chame Qualquer Modelo do Seu Código

O Inference Providers oferece uma única API que roteia para 18 parceiros de computação sem acréscimo sobre as tarifas dos provedores. A URL base https://router.huggingface.co/v1 é compatível com a OpenAI para completions de chat, então você pode usar o SDK Python ou JavaScript da OpenAI alterando apenas uma linha.

Instale o cliente Hugging Face Hub:

pip install huggingface_hub

Chame um modelo de linguagem usando o cliente nativo:

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)

Se você já usa o cliente Python da OpenAI, troque a URL base:

from openai import OpenAI
import os

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

A seleção do provedor é controlada por um sufixo no ID do modelo. :fastest (padrão) escolhe o provedor com maior throughput para aquele modelo. :cheapest minimiza o custo por token de saída. Você pode fixar um provedor específico pelo nome, por exemplo "openai/gpt-oss-120b:groq".

O endpoint compatível com OpenAI cobre apenas completions de chat. Para geração de imagens, embeddings e reconhecimento de fala, use os métodos do InferenceClient diretamente:

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

Execute Modelos Localmente com a Biblioteca Transformers

Para uso offline, fine-tuning ou quando você precisa de controle total sobre a pilha de inferência, baixe e execute modelos localmente com o transformers.

Instale as bibliotecas principais:

pip install -U transformers datasets evaluate accelerate timm

A função pipeline() é o caminho mais rápido para inferência local. Ela baixa e armazena em cache os pesos do modelo do Hub na primeira chamada:

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"))

Para maior controle, use AutoModel e AutoTokenizer diretamente:

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" é importante: sem ele, o PyTorch usa float32 por padrão, dobrando a VRAM necessária para um modelo armazenado em bfloat16. device_map="auto" gerencia configurações multi-GPU e o offloading automático de pesos da GPU para a CPU.

Os pesos dos modelos em cache ficam em ~/.cache/huggingface/hub por padrão. Defina a variável de ambiente HF_HOME para mover o cache para outro disco.

Para times que desenvolvem sobre o transformers, veja o guia de AI Weekly sobre assistentes de codificação com IA para entender como essas bibliotecas se encaixam em fluxos de desenvolvimento mais amplos.

Crie e Hospede um App de Demonstração com Spaces

Os Spaces são a camada de apps web hospedados do Hub. Você faz push de um app Gradio ou Streamlit para um repositório de Space, e o Hugging Face o serve via HTTPS com uma URL pública. Contas gratuitas recebem uma CPU compartilhada (2 vCPU / 16 GB RAM) sem custo.

ZeroGPU é a opção de GPU do plano gratuito. Ele aloca GPUs NVIDIA RTX Pro 6000 Blackwell dinamicamente, apenas enquanto um usuário está executando inferência ativamente, e libera a GPU imediatamente depois. Você não paga nada pelo tempo ocioso.

O ZeroGPU tem dois tamanhos: large (metade da GPU, 48 GB de VRAM) e xlarge (GPU completa, 96 GB de VRAM). O tamanho xlarge consome 2x da sua cota diária.

Para usar o ZeroGPU em um 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()

O decorator @spaces.GPU solicita uma GPU quando a função é chamada e a libera ao retornar. Carregue os modelos no CUDA no nível do módulo (fora da função decorada): o lazy-loading dentro do decorator é significativamente mais lento porque as transferências CUDA otimizadas na inicialização são ignoradas.

O ZeroGPU funciona apenas com Spaces Gradio. Spaces Docker e Streamlit exigem uma camada de hardware alugada. Contas gratuitas podem hospedar até 2 Spaces ZeroGPU; contas PRO, até 10; contas de organização (Team ou Enterprise), até 50.

Quando a cota diária de ZeroGPU se esgota, cada 10 minutos adicionais de GPU custam $1, cobrados de um saldo de crédito pré-carregado que você pode adicionar nas configurações de cobrança.

Para endpoints de GPU de execução contínua e privados (APIs de produção, servidores de modelos dedicados), o Inference Endpoints implanta qualquer modelo do Hub em hardware gerenciado e reservado, cobrado por hora.

O Que Custa na Prática

O plano de assento e a fatura de computação são separados. A assinatura mensal compra funcionalidades e cotas de uso; a inferência real e o tempo de GPU são cobrados adicionalmente.

Plano	Preço	Cota diária ZeroGPU	Spaces ZeroGPU (hospedados)	Ideal para
Free	$0	5 minutes	2	Aprendizado e experimentação
PRO	$9/month	40 minutes (extensible)	10	Profissionais individuais e usuários avançados
Team	$20/user/month	40 minutes (extensible)	50 org-wide	Times que precisam de SSO, logs de auditoria e controles de acesso
Enterprise	$50/user/month	60 minutes (extensible)	50 org-wide	Organizações que precisam de compliance, provisionamento SCIM e suporte dedicado

Os custos de computação são cobrados adicionalmente a qualquer plano de assinatura. Principais valores da página de preços oficial:

• Excedente do ZeroGPU: $1 por 10 minutos após o esgotamento da cota diária
• Hardware GPU para Spaces dedicados: T4 small a $0.40/hour, A100 (80 GB) a $2.50/hour
• Inference Endpoints (servidores de modelo dedicados): T4 a $0.50/hour, H100 a $4.50/hour, H200 (141 GB) a $5.00/hour, B200 (179 GB) a $9.25/hour
• Armazenamento no Hub: $12/TB/month para repositórios públicos, $18/TB/month para repositórios privados no volume base; descontos por volume se aplicam acima de 50 TB e 200 TB

Para experimentos curtos e tráfego irregular, o Inference Providers (serverless) é quase sempre mais barato que um endpoint dedicado. Os endpoints dedicados fazem sentido quando você precisa de latência garantida, de executar um modelo privado ou fine-tuned, ou quando o tráfego é consistente o suficiente para que a cobrança por hora saia mais barata que a cobrança por solicitação.

Perguntas Frequentes

Preciso de uma GPU para usar o Hugging Face?
Para testes no navegador e chamadas de API do Inference Providers, não: a computação roda na infraestrutura dos parceiros. Para inferência local com transformers, uma CPU funciona para modelos pequenos, mas a geração será lenta. Uma GPU CUDA é recomendada para qualquer modelo com mais de alguns bilhões de parâmetros. O Apple Silicon (série M) é suportado pelo backend MPS e executa modelos de médio porte com velocidade razoável.

Qual é a diferença entre Inference Providers e Inference Endpoints?
O Inference Providers é serverless e compartilhado: você chama um modelo pelo roteador, as solicitações são balanceadas entre as computações disponíveis, e você paga por solicitação (ou usa créditos do plano gratuito). O Inference Endpoints implanta um contêiner dedicado e sempre ativo com seu modelo escolhido em hardware reservado, cobrado por hora. O Providers é indicado para experimentação e cargas de trabalho variáveis; o Endpoints é para casos de uso em produção que exigem latência garantida, throughput consistente ou um modelo privado ou fine-tuned que não pode ser exposto pelo roteador compartilhado.

Posso usar modelos do Hugging Face em produtos comerciais?
Depende da licença de cada modelo, não do seu plano no Hugging Face. Verifique o campo de licença no Model Card antes de colocar qualquer coisa em produção. Modelos Apache 2.0 geralmente podem ser usados comercialmente com atribuição. Modelos sob a Llama 3 Community License ou os Termos de Uso do Gemma têm restrições comerciais vinculadas a contagens de usuários ou categorias de uso. Modelos exclusivos para pesquisa proíbem totalmente o uso comercial. O filtro de licença do Hub em huggingface.co/models permite pesquisar por tipo de licença específico.

Como faço o download de um modelo para usar offline?
Use a CLI: hf download meta-llama/Llama-2-7b-hf baixa o checkpoint para o cache local. No Python, chamar from_pretrained() aciona o mesmo download automaticamente. Após o download, defina HF_HUB_OFFLINE=1 como variável de ambiente para evitar chamadas de rede durante a inferência. Os arquivos em cache ficam em ~/.cache/huggingface/hub, a menos que você tenha definido HF_HOME.

O Que é um Model Card e Por Que Importa Antes de Implantar?
Um Model Card é o arquivo de documentação que acompanha cada modelo do Hub. Ele cobre uso pretendido, usos fora do escopo, vieses conhecidos, detalhes do dataset de treinamento e benchmarks de avaliação. Para qualquer time com requisitos de IA responsável ou obrigações regulatórias, o Model Card é o artefato principal para auditar um modelo de terceiros antes de colocá-lo em produção. Modelos sem cards completos devem ser tratados como subdocumentados, independentemente de suas pontuações em benchmarks.

Fique por dentro de tudo que está sendo lançado na pilha de IA. Receba o AI Weekly grátis, 3 edições por semana, lido por 40,000+ profissionais de IA.