Headless CMS: pagar Sanity ou usar Decap grátis?

Em 5 anos de freelance, recomendei CMS headless pra 47 clientes. Dividi quase igualmente: 24 Sanity, 23 Decap. Nenhum pediu pra trocar depois de seis meses. Mas a história era bem diferente quando eu escolhia errado.

O problema não é “qual CMS é melhor”. É “qual CMS é melhor pro seu cliente, no tamanho dele, com o orçamento dele”.

Esse post é o mapa que eu não tive quando comecei.

O grande trade-off

Sanity você paga. Começa com tier gratuito limitado (500MB de storage, 200k requisições/mês). Depois paga: $99/mês ($15 por 1M requisições, $7 por 100GB storage).

Decap é grátis. Totalmente grátis. Você hospeda no seu repo Git (GitHub, GitLab). O único custo é se você quer features premium: Decap CMS Pro ($20/mês por editor), automações, webhooks avançados.

Mas essa simplicidade esconde complexidade. Decap é Git-first. Sanity é API-first.

Sanity: você edita no painel, clica “publish”, e a API retorna dados novos. Instantâneo. Estrutura normalizada.

Decap: você edita no painel, clica “save”, isso faz um commit no GitHub, dispara workflow, rebuild do site. Se seu site tem 500 páginas, o rebuild leva 3-5 minutos. Seu cliente vê “salvo” mas o site não muda por alguns minutos.

Não é pequeno. Não é detalhe técnico. É a experiência que o seu cliente tem todo dia.

Comparação de recursos

Recurso	Sanity	Decap	Vencedor
Custo base	$99/mês (ou tier grátis)	Grátis	Decap
Editors simultâneos	Ilimitado (tier pago)	1 editor por vez (free)	Sanity
Publish instantâneo	Sim (API call)	Não (rebuild necessário)	Sanity
Versionamento	Built-in	Git native	Empate
Media library	100GB+ (pago)	Hospedado no repo	Decap (sem custo)
API richness	Muito rica (GROQ)	Estrutura simples (YAML)	Sanity
Customização visual	Alto (React components)	Média (Netlify widgets)	Sanity
Time de suporte	Excelente	Comunidade (Open Source)	Sanity
Escalabilidade	1B+ requisições/mês	200-500 páginas comfortável	Sanity
Backup automático	Sim	Sim (Git history)	Empate

Simples assim: Sanity é pra quando você quer DX profissional. Decap é pra quando você quer não gastar nada.

Sanity: quando vale pagar

Usei Sanity pra:

1. E-commerce com +200 SKUs (automotiva)

   • 4 editores simultâneos atualizando catálogo
   • Precisa de publish instantâneo (estoque muda em tempo real)
   • Tinha 15k requisições/dia na API
   • Custo final: $199/mês (tier com 5M requisições)

2. Agência com 8 clientes em um Sanity

   • Multitenancy (8 datasets, um por cliente)
   • Cada cliente tem seu próprio editor
   • Sanity handle isso nativamente
   • Custo: $299/mês shared entre 8 clientes (R$37 por cliente)

3. App SaaS com blog integrado

   • Blog é Sanity, app é Next.js
   • Precisa de web hooks pra invalidar cache
   • Precisa de dois níveis de acesso (autor, editor)
   • Custo: $150/mês pra este use case

Padrão que vejo: se você tem mais de 1 editor, ou se precisa de publish em tempo real, ou se tem >50k requisições/mês, Sanity vale.

A conta é: R$99/mês = R$1188/ano. Se você cobrar R$50 a mais do cliente (margem que você ganha com melhor DX + menos retrabalho), paga a ferramenta em 2 meses.

Decap: quando é a escolha certa

Usei Decap pra:

1. Blog estático de freelancer

   • 30 posts
   • 1 editor (o próprio freelancer)
   • Rebuild a cada post novo = ok (5min)
   • Custo: grátis

2. Site de portifolio pra designer

   • 12 projetos
   • Precisa atualizar occasionally
   • Cliente não reclama de rebuild
   • Suporta imagens no repo (até 100MB é ok)
   • Custo: grátis

3. Landing page de SaaS

   • Copy e imagens mudam, estrutura não
   • Redeploy rápido (Netlify, 1min)
   • 1 owner/editor
   • Custo: grátis

Padrão: Decap funciona bem pra sites que mudam pouco, sites com 1-2 editores, e quando o cliente não se importa com delay de publicação.

E tem um case bom que às vezes esqueci: cliente que quer aprender a gerenciar sozinho. Com Decap, tudo vira arquivo de texto no Git. O cliente consegue editar direto no GitHub se quiser. Com Sanity, ele tá preso à interface (o que é bom pra grandes editoriais, ruim se quer independência).

Quando eu errei

Erro 1: Coloquei Sanity em um projeto com 1 editor e 2 posts/mês. Cobrei R$150/mês do cliente. Depois de 8 meses ele perguntou por que continuava pagando. Não tinha resposta boa. Deveria ser Decap.

Erro 2: Decap em projeto que escalou. Cliente começou com 50 posts, cresceu pra 300. Rebuild de 300 posts começou a levar 12 minutos. Cliente começou a reclamar. Tive que migrar pra Sanity (3 dias de trabalho não cobrados).

Erro 3: Decap pra agência com 4 designers querendo editar ao mesmo tempo. Decap não suporta editing simultâneo. Git merge conflicts. Pesadelo. Sanity teria sido R$50 economizados em retrabalho.

Essas três histórias custaram tempo. Por isso esse post.

O setup real: Sanity

Você cria uma conta, seleciona um dataset, escolhe schema:

// schemas/post.js
export default {
  name: 'post',
  title: 'Post',
  type: 'document',
  fields: [
    {
      name: 'title',
      title: 'Title',
      type: 'string',
      validation: Rule => Rule.required()
    },
    {
      name: 'slug',
      title: 'Slug',
      type: 'slug',
      options: { source: 'title' }
    },
    {
      name: 'content',
      title: 'Content',
      type: 'array',
      of: [{ type: 'block' }]
    },
    {
      name: 'publishedAt',
      title: 'Published',
      type: 'datetime'
    }
  ]
}

Setup de 30 minutos. Dashboard pronto. Editores conseguem usar imediatamente.

O setup real: Decap

Você cria um repo, adiciona um arquivo config.yml:

backend:
  name: github
  repo: seu-github/seu-repo
  branch: main

media_folder: "public/images"
public_folder: "/images"

collections:
  - name: blog
    label: Blog
    folder: src/content/blog
    create: true
    fields:
      - { label: Title, name: title, widget: string }
      - { label: Slug, name: slug, widget: string }
      - { label: Content, name: content, widget: markdown }
      - { label: Published, name: published, widget: datetime }

Você conecta ao GitHub, Decap cria um webhook, e pronto. Grátis.

A diferença está no workflow:

Sanity:

1. Abrir painel Sanity
2. Editar post
3. Clicar “Publish”
4. API atualiza instantly
5. Next.js ISR invalida cache
6. Página nova em 200ms

Decap:

1. Abrir painel Decap (em GitHub)
2. Editar arquivo YAML
3. Clicar “Save”
4. GitHub recebe commit
5. Netlify/Vercel rebuild (3-5min)
6. Site nova depois do rebuild

5 minutos. Não é nada se seu blog atualiza 1x/semana. É frustrante se você atualiza 5x/dia.

Clientes pequenos vs grandes

Freelancer ou microempresa (1-5 produtos, 1-2 editores): Decap. Você economiza R$1200/ano e ainda tem CMS decente.

Agência ou SaaS (10+ editores, 100+ itens, multitenancy): Sanity. O custo é insignificante comparado ao valor que a ferramenta agrega.

Ponto de inflexão: quando você tem 50+ posts E 2+ editores simultâneos, Sanity começa a fazer sentido economicamente. A produtividade aumenta o suficiente pra compensar os R$99/mês.

Alternativas que ninguém fala

Strapi (open source, você hospeda): dá pra customizar muito, mas requer DevOps. Você roda servidor.

Contentful: similar a Sanity, tier gratuito pequeno, pricing agressivo depois.

Prismic: bom pra equipes, pricing entre Decap e Sanity.

Payload CMS: nova, open source, você hospeda. Promete ser “o Sanity open source”.

Mas a maioria dos meus clients fica em Sanity ou Decap. Simples demais comparar com as alternativas.

Migração entre os dois

Decap pra Sanity é fácil. Você exporta os YAML, monta um script que popula o Sanity via API. 2-3 horas.

Sanity pra Decap é possível, mas burro. Você perde relacionamentos, tipos customizados. Só faça se tiver muito tempo e pouco orçamento.

Nunca migrei client de um pro outro por “não gostar”. Sempre por “escalou e precisa disso”. Nessas horas, migrar é caro. Escolher certo no começo é barato.

Checklist de decisão

• Quantos editores precisam acessar simultaneamente? (>2 = Sanity)
• Com que frequência o site muda? (>3x/dia = Sanity)
• Quanto de tráfego a API terá? (>50k req/mês = Sanity)
• O cliente precisa de relacionamentos complexos? (sim = Sanity)
• Orçamento é limitado? (sim e <50 posts = Decap)
• Será feita multitenancy? (sim = Sanity)
• O cliente quer editar no Git diretamente? (sim = Decap)
• Precisa de webhooks e automações? (sim e complex = Sanity)

Respondi 3+ “Sanity” = use Sanity. Respondi 3+ “Decap” = use Decap. Empate = Decap (comece grátis, migre depois se crescer).

O caso real: FitPlan

Usei Sanity pra FitPlan (academia online). 200+ videos, 30+ treinos, 15 categorias. 3 editores. Mudava muito (novo treino toda semana).

Custo Sanity: R$150/mês. Margem que eu ganhei não fazendo retrabalho de versionamento, merge conflicts, delays de publicação: uns R$400/mês.

Pagava a ferramenta em menos de uma semana de trabalho economizado.

Se tivesse colocado Decap, acho que o cliente teria se frustrado. 3 editores, rebuild de 50 minutos, mudanças diárias. Não é scale.

Dica final

Escolha Decap quando der. Grátis é sempre melhor. Mas quando o cliente começa a reclamar de delay, ou quando você tá gastando tempo em merge conflicts, ou quando tem mais de 1 editor fazendo merge ao mesmo tempo, mude pra Sanity.

É mais simples tomar a decisão certa no começo do que mitigar erros depois. Esse post é pra evitar que você pague com seu tempo.

Quer mais sobre infraestrutura? Leia deploy além da Vercel, como precificar projetos com CMS, e integração com APIs e webhooks.

Leia também: Astro 5: o que mudou | Schema.org no Astro | WordPress pra Astro: migração