Três formas gratuitas de colocar um servidor MCP online: Vercel Hobby, Cloudflare Workers e hosts Docker como Render, Cloud Run e Hugging Face Spaces. Limites reais verificados em outubro de 2026, código funcional, segurança de tokens e uma tabela mostrando qual opção falha primeiro.
Seu servidor MCP roda perfeitamente no seu laptop. O Claude Desktop o inicia via stdio, todas as ferramentas respondem, e então você faz uma pergunta mais difícil: como deixar o Cursor em outra máquina, um colega de equipe ou um conector do ChatGPT acessar as mesmas ferramentas sem pagar por um servidor? Você precisa de uma URL HTTPS pública, e gostaria que a conta saísse em US$ 0.
Você pode hospedar um servidor MCP grátis em três plataformas bem diferentes: Vercel, Cloudflare Workers e qualquer host Docker com plano gratuito. Cada uma combina com um tipo diferente de servidor, e cada uma tem um limite em que você vai esbarrar, mais cedo ou mais tarde. Abaixo você encontra os números reais, verificados na documentação oficial dos fornecedores em outubro de 2026, código funcional para cada caminho e uma lista curta do que quebra primeiro.
💡 Os planos gratuitos mudam com frequência. Todos os limites deste artigo vêm da documentação oficial em outubro de 2026. Confira a página de preços novamente antes de lançar qualquer coisa pública.
Um servidor stdio é um processo filho. O cliente o inicia, conversa pela entrada e saída padrão, e o encerra quando a sessão termina. Nada sai da sua máquina, o que torna o stdio perfeito para ler arquivos locais e inútil para compartilhar.
Um servidor remoto escuta em uma única URL, normalmente /mcp ou /api/mcp, e fala Streamable HTTP. Qualquer cliente que tenha o endereço e o token certo pode chamá-lo de qualquer lugar. O transporte HTTP+SSE, mais antigo, está saindo de cena: a v2 do mcp-handler da Vercel o removeu, e a documentação atual da Cloudflare descreve apenas Streamable HTTP em /mcp. Se você construir para esse transporte, não vai enfrentar uma reescrita no ano que vem.
Antes de comparar plataformas, anote o que o seu servidor realmente precisa:
A hospedagem é um problema de rede antes de ser um problema de código: um endereço, uma porta aberta, um processo que responde. Cada opção abaixo resolve essas três coisas de um jeito diferente.
Vercel e Cloudflare executam seu código como funções serverless: sem máquina para gerenciar, cobrança por uso e gratuitas até um teto. Hosts Docker executam seu código como um contêiner: um processo completo, com sistema de arquivos próprio e qualquer linguagem que você quiser. Essa diferença define a maior parte das contrapartidas.
| Opção | Franquia gratuita | Inicialização | Ideal para | Principal pegadinha |
|---|---|---|---|---|
| Vercel Hobby | 1M de invocações, 4 horas de CPU, 300 s por chamada | Curta, as instâncias são reutilizadas | Equipes Next.js, deploys rápidos | Somente uso pessoal, não comercial |
| Cloudflare Workers Free | 100.000 requisições por dia, 10 ms de CPU cada | Desprezível | Ferramentas leves, muitas chamadas | 10 ms de CPU, 50 subrequisições |
| Render Free | 750 horas de instância por mês | Cerca de 1 minuto após 15 minutos ociosos | Qualquer Dockerfile | Entra em suspensão quando ocioso |
| Google Cloud Run | 2M de requisições, 180.000 segundos de vCPU | Escala a zero, primeira chamada mais lenta | Contêineres com tráfego em rajadas | Exige uma conta de faturamento |
| Hugging Face Spaces | CPU Basic gratuita (2 vCPU, 16 GB de RAM) | Spaces ociosos podem pausar | Demos públicas | O disco é zerado ao reiniciar |
Leia a tabela por linhas, não por colunas. A coluna de inicialização prevê como o servidor se comporta dentro de um chat: Workers e Vercel respondem em milissegundos, enquanto um contêiner adormecido faz a primeira chamada de ferramenta travar. A coluna de franquia gratuita prevê por quanto tempo você continua sem pagar: 100.000 requisições por dia parecem enormes até que um agente tagarela repita uma ferramenta quarenta vezes por tarefa.
💡 As cinco opções custam US$ 0 no primeiro dia, então o preço é o critério de desempate errado. Escolha pelo que uma única chamada de ferramenta faz: uma consulta rápida, um cálculo pesado ou uma longa espera por outra API.
Se o seu projeto já vive em um app Next.js com App Router, um servidor MCP é um arquivo a mais. A Vercel o executa como uma Function com Fluid compute, que cobra separadamente a CPU ativa e o tempo de memória. Isso combina bem com o tráfego de MCP: longos períodos ociosos e depois uma rajada de chamadas.
Você precisa do Node.js 20 ou mais recente. A documentação da Vercel fixa essas versões:
npm i mcp-handler@2.1.1 @modelcontextprotocol/server@2 zod@4
Crie app/api/mcp/route.ts:
import { createMcpHandler } from 'mcp-handler';
import { z } from 'zod';
const handler = createMcpHandler((server) => {
server.registerTool(
'roll_dice',
{
description: 'Roll an N-sided die',
inputSchema: z.object({ sides: z.number().int().min(2) }),
},
async ({ sides }) => {
const value = 1 + Math.floor(Math.random() * sides);
return { content: [{ type: 'text', text: `You rolled a ${value}` }] };
},
);
});
export { handler as GET, handler as POST };
Envie para o Git, importe o repositório na Vercel, e o servidor responde em https://your-app.vercel.app/api/mcp. No Cursor, a configuração é uma única linha: {"mcpServers": {"dice": {"url": "https://your-app.vercel.app/api/mcp"}}}. Teste localmente primeiro com npx @modelcontextprotocol/inspector@latest, escolha Streamable HTTP e aponte para http://localhost:3000/api/mcp.
Uma ferramenta que passa a maior parte do tempo esperando outra API mal toca nas 4 horas de CPU. Uma ferramenta que processa arquivos grandes as consome rápido. Planeje também em torno do teto de 300 segundos: retorne um ID de tarefa logo e deixe uma segunda ferramenta verificá-lo, em vez de manter uma chamada aberta por minutos.
💡 Se um cliente receber uma página de login em vez de JSON, verifique o Deployment Protection. Projetos Hobby podem ter a Vercel Authentication ativada, e ela bloqueia chamadores anônimos, incluindo o seu cliente MCP.
Os Workers rodam dentro de isolates V8, então não há contêiner para inicializar. Isso combina com o formato sem estado de requisição e resposta da maioria dos servidores MCP, e é por isso que o tempo de inicialização fica perto de zero.
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless
O template serve Streamable HTTP em /mcp. A documentação da Cloudflare agora recomenda createMcpHandler para novos servidores: ele é sem estado e cria um servidor MCP por requisição. A classe McpAgent, mais antiga, está documentada como obsoleta e sem novos recursos, então evite-a em qualquer projeto novo.
export default {
fetch(request, env, ctx) {
return createMcpHandler(createServer)(request, env, ctx);
},
} satisfies ExportedHandler;
Envolva o handler em um método fetch. Se você exportar a função chamável diretamente, o Wrangler lê um export default de função como uma classe WorkerEntrypoint e o deploy se comporta mal.
Esperar por uma chamada fetch() não conta no tempo de CPU, então uma ferramenta que chama uma API externa e devolve a resposta cabe com folga. Análise pesada ou processamento de imagens não cabem. Ao passar do teto diário, a Cloudflare retorna Erro 1027.
A autenticação já está resolvida aqui. Os templates OAuth oferecem suporte a GitHub, Google, Slack, Auth0, Stytch, WorkOS e Cloudflare Access, com um namespace de KV guardando as sessões. O estado, se você precisar dele, pode ficar no KV ou em Durable Objects com SQLite, que estão disponíveis no plano gratuito.
Escolha um contêiner quando o servidor precisar de bibliotecas nativas, arquivos locais, uma tarefa de longa duração ou uma linguagem diferente de TypeScript. Você troca a inicialização instantânea por liberdade.
FROM node:22-slim AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM node:22-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=build /app/dist ./dist
ENV PORT=8080
EXPOSE 8080
CMD ["node", "dist/http.js"]
Duas regras importam. Escute na porta que o host fornece lendo PORT, e faça o bind em 0.0.0.0, não em localhost. Depois rode o servidor no modo Streamable HTTP sem estado, para que qualquer instância possa responder a qualquer requisição. Hosts que escalam a zero descartam sessões em memória sem aviso.
sdk: docker e app_port: 7860 ao cabeçalho YAML do seu README. O contêiner roda como o usuário 1000, e tudo o que for gravado no disco é perdido na reinicialização.O serviço gratuito do Render entra em suspensão após 15 minutos sem tráfego, e acordá-lo leva cerca de um minuto. Um cliente com timeout curto falha na primeira requisição e funciona na segunda. Esse bug é terrível de rastrear se você não souber a causa.
Você tem três opções:
Uma URL MCP é um controle remoto para tudo o que as suas ferramentas podem fazer. Qualquer pessoa que a encontre pode apertar os botões, e os planos gratuitos não têm teto de orçamento que impeça um estranho de consumir a sua cota.
Na Vercel, envolva o handler com withMcpAuth, defina required: true e retorne o cliente verificado de verifyToken. Requisições sem token válido recebem um 401. Um token sem um escopo exigido recebe um 403. O exemplo da documentação lê um token de demonstração de uma variável de ambiente, e diz que, em produção, o código deve verificar emissor, audiência, expiração e escopos com um servidor de autorização real. mcp-handler não emite tokens por conta própria.
Para atender à especificação MCP, publique também os metadados de recurso protegido OAuth em /.well-known/oauth-protected-resource, para que clientes compatíveis encontrem o seu servidor de autorização.
npx wrangler secret put PICASSOIA_TOKENNunca cole um token em uma descrição de ferramenta ou em um prompt. Os clientes mostram as descrições das ferramentas ao modelo, e o modelo pode repeti-las. Adicione também um contador de chamadas por token, já que a cota gratuita é compartilhada por todos os chamadores.
Nada impede que você combine as opções. Uma configuração comum é um Worker que responde consultas baratas e encaminha requisições pesadas para um contêiner, de modo que o cliente sempre recebe uma primeira resposta rápida. Comece pela plataforma mais simples que atenda ao seu caso, meça durante uma semana e só mude quando um limite realmente começar a pesar.
| Plataforma | Primeiro muro que você encontra | Sinal de alerta |
|---|---|---|
| Vercel Hobby | 4 horas de CPU, ou a regra de uso não comercial | Recursos pausados, espera de 30 dias |
| Workers Free | 10 ms de CPU em ferramentas pesadas | Erros de limite de CPU ao analisar arquivos |
| Render Free | Atraso na inicialização | Primeira chamada falha após período ocioso |
| Cloud Run | Uso além da franquia gratuita | Cobranças na fatura |
| Spaces | Disco é zerado | Estado desaparece após um reinício |
Um servidor hospedado só é útil se as suas ferramentas fizerem algo que valha a pena chamar. A geração de imagens é uma boa primeira ferramenta, porque você vê de imediato se o ciclo inteiro funciona.
A PicassoIA expõe uma API no estilo Replicate em https://api.picassoia.com/v1. Você se autentica com um token Bearer que começa com pia_sk_, cria uma predição e depois a consulta. O modelo PicassoIA Image recebe um objeto input com um prompt e um aspect_ratio:
server.registerTool(
'make_image',
{
description: 'Start an image generation from a text prompt',
inputSchema: z.object({ prompt: z.string().min(10) }),
},
async ({ prompt }) => {
const res = await fetch(
'https://api.picassoia.com/v1/models/picassoia/picassoia-image/predictions',
{
method: 'POST',
headers: {
Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({ input: { prompt, aspect_ratio: '16:9' } }),
},
);
if (!res.ok) {
return { isError: true, content: [{ type: 'text', text: `API error ${res.status}` }] };
}
const prediction = await res.json();
return {
content: [{ type: 'text', text: `Prediction ${prediction.id} is ${prediction.status}` }],
};
},
);
No Workers, leia o token de env em vez de process.env. As predições são assíncronas, então divida o trabalho em duas ferramentas: make_image retorna o ID da predição, e check_image chama GET /v1/predictions/{id} e devolve o status e as URLs de saída. Os status são starting, processing, succeeded, failed e canceled. Cada chamada termina em milissegundos, o que cabe no orçamento de 10 ms de CPU dos Workers e nunca mantém uma requisição aberta. O limite da conta é 5 predições ao mesmo tempo, compartilhado entre tokens e conexões MCP.
💡 A documentação da API diz que as predições são atualmente gratuitas e não usam créditos, e também diz que é preciso um plano Infinite para criá-las. Confira a página de preços antes de construir uma ferramenta pública sobre isso.
Publique o servidor de dados hoje à noite, depois abra a Picasso IA e crie algo com ele. Escreva um prompt, rode-o pelo Seedream 5 Pro e pelo Nano Banana 2 Lite, e compare os dois resultados lado a lado. Quando a sua própria ferramenta MCP devolver uma URL de imagem em um servidor que não custa nada, o ciclo completo estará funcionando, e cada nova ferramenta depois disso leva minutos. Teste alguns prompts, quebre alguns limites de propósito e veja qual host gratuito aguenta o seu projeto.
Escolha seu idioma
