A US$ 0,40 por hora, um teste de 90 segundos custa 1¢ (¢ = centavo de dólar) se você for cobrado por segundo com mínimo de 60 segundos, 1,3¢ se for cobrado por minuto e 40¢ se for cobrado por hora cheia. Essa diferença de 40 vezes é tudo o que importa em trabalhos curtos. Quando um trabalho passa de alguns minutos, a cobrança por segundo e a por minuto diferem em menos de um centavo, e quem decide a conta é o tempo ocioso, o tempo de preparação e o armazenamento.
Abaixo: as regras publicadas de cada plataforma, exemplos com as contas, um gráfico em escala e como o modelo do GPUFlow, que reserva primeiro e devolve o resto, vira uma cobrança. Regras e preços são de setembro de 2026; as fontes estão no final.
Três formas de contar o tempo de GPU
Todo aluguel de GPU tem um preço por hora. A diferença está em como o tempo que você usou vira tempo cobrável antes de ser multiplicado por esse preço.
- Por segundo, com mínimo. Contam-se os segundos. Se o total ficar abaixo do mínimo (geralmente 60 segundos), cobra-se o mínimo. Custo = max(60, segundos) × preço por hora / 3.600.
- Por minuto. Contam-se os minutos. As plataformas tratam o minuto parcial de formas diferentes: algumas arredondam para cima, o Azure descarta. Nos exemplos abaixo eu arredondo para cima, que é o pior caso para você. Custo = minutos × preço por hora / 60.
- Hora cheia. Qualquer hora iniciada conta como hora inteira. Um trabalho de 61 minutos vira duas horas. Custo = ceil(segundos / 3.600) × preço por hora.
O mínimo pesa mais do que se imagina. Cobrança por segundo com mínimo de 60 segundos e cobrança por minuto são idênticas para qualquer coisa abaixo de um minuto. O incremento só muda a fração que sobra no fim de um trabalho, então nunca pode custar mais do que um incremento por sessão: pouco menos de 40¢ por sessão na cobrança por hora a US$ 0,40, e menos de 0,7¢ por sessão na cobrança por minuto com o mesmo preço (59 segundos × 40 / 3.600 = 0,66¢).
O que cada plataforma usa
Estas são as regras publicadas para instâncias sob demanda, conferidas na documentação de cada fornecedor em setembro de 2026.
| Plataforma | Incremento | Mínimo | O que diz a documentação |
|---|---|---|---|
| AWS EC2 On-Demand | Por segundo | 60 segundos | Vale para Linux, Windows, RHEL e Ubuntu Pro. SUSE Linux Enterprise Server é cobrado por hora cheia. |
| Google Cloud Compute Engine | Por segundo | 1 minuto | ”Todas as vCPUs, GPUs e GB de memória são cobrados por no mínimo 1 minuto.” |
| Azure Virtual Machines | Por minuto | Não informado | Cobra “o número de minutos completos”; uma VM que roda 6 min 45 s é cobrada por 6 minutos. |
| Lambda (nuvem sob demanda) | Por minuto | Não informado | Cobra “em incrementos de um minuto” desde que a instância passa nas verificações de saúde até você encerrá-la. |
| RunPod Pods | Por segundo | Não informado | Computação e armazenamento cobrados por segundo. |
| Vast.ai | Por segundo | Não informado | Aluguel ativo cobrado a cada segundo; armazenamento cobrado a cada segundo em que a instância existe, a menos que esteja offline. |
| GPUFlow | Por segundo | 60 segundos | Segundos inteiros, arredondados para cima até o centavo, limitados ao valor reservado. |
Duas observações para ler a tabela. A regra do Azure na verdade arredonda para baixo: o FAQ diz que você “não é cobrado por segundos extras”. A documentação da Lambda fala em incrementos de um minuto sem dizer para que lado vai o minuto parcial, então não supus nenhum dos dois. E “não informado” quer dizer exatamente isso: a documentação que li não cita um mínimo, o que é diferente de um zero documentado.
Nenhuma dessas plataformas arredonda a computação de GPU para a hora cheia nos tipos de instância acima. O arredondamento por hora ainda aparece nas letras miúdas, como no caso do SUSE na AWS, então confira a página de cobrança antes de rodar muitos trabalhos curtos num lugar novo.
Cinco trabalhos a US$ 0,40 por hora
Aqui está um único preço, US$ 0,40 por hora, aplicado a cinco durações. Isso dá 40¢ a cada 3.600 segundos, ou 1/90 de centavo por segundo.
Um teste de 90 segundos. Por segundo: 90 × 40 / 3.600 = 1,0¢. Por minuto: 2 minutos × 40 / 60 = 1,33¢. Hora cheia: 40¢. A conta por hora sai 40 vezes a conta por segundo.
7 minutos e 30 segundos. Por segundo: 450 × 40 / 3.600 = 5,0¢. Por minuto: 8 minutos × 40 / 60 = 5,33¢. Hora cheia: 40¢, 8 vezes mais.
38 minutos e 20 segundos. Por segundo: 2.300 × 40 / 3.600 = 25,56¢. Por minuto: 39 minutos × 40 / 60 = 26,0¢. Hora cheia: 40¢, cerca de 1,57 vez mais.
61 minutos. Por segundo: 3.660 × 40 / 3.600 = 40,67¢. Por minuto: 61 × 40 / 60 = 40,67¢ (o trabalho termina num minuto exato, então os dois coincidem). Hora cheia: duas horas, 80¢. Um minuto a mais quase dobra a conta por hora.
| Duração do trabalho | Por segundo (mín. 60 s) | Por minuto (para cima) | Hora cheia | Cobrança no GPUFlow |
|---|---|---|---|---|
| 1 min 30 s | 1,00¢ | 1,33¢ | 40¢ | 1¢ |
| 7 min 30 s | 5,00¢ | 5,33¢ | 40¢ | 5¢ |
| 38 min 20 s | 25,56¢ | 26,00¢ | 40¢ | 26¢ |
| 61 min | 40,67¢ | 40,67¢ | 80¢ | 41¢ |
| 20 trabalhos de 2 min 30 s | 33,33¢ | 40,00¢ | US$ 8,00 | 40¢ (20 aluguéis) |
A coluna do GPUFlow é o resultado por segundo arredondado para cima até o centavo inteiro em cada aluguel, que é o que o código de cobrança dele faz. A última linha é explicada duas seções adiante.
Custo por duração do trabalho, em escala
O primeiro gráfico vai de 0 a 150 minutos. A escada da cobrança por minuto tem degraus de 1 minuto de largura e 0,67¢ de altura, então nesta escala ela fica em cima da linha por segundo. A escada que importa é a da hora cheia: ela salta 40¢ em 0, 60 e 120 minutos.
A distância entre a escada laranja e a linha azul é o que o arredondamento por hora custa por trabalho: máxima logo depois de cada degrau, zero em horas exatas.
Ampliando os primeiros dez minutos, a cobrança por minuto mostra os seus degraus, e o mínimo de 60 segundos aparece como o início plano da linha por segundo. A cobrança por hora cheia seria uma linha reta em 40¢, cinco vezes acima do topo deste gráfico.
Um dia de trabalhos curtos
Trabalho curto raramente vem sozinho. Digamos que você rode 20 trabalhos num dia de expediente, cada um de 2 minutos e 30 segundos, e suba uma instância nova para cada um.
- Por segundo: 20 × 150 s = 3.000 s, e 3.000 × 40 / 3.600 = 33,33¢.
- Por minuto, arredondando para cima: cada trabalho vira 3 minutos, 60 minutos no total: 40¢.
- Hora cheia: cada trabalho é uma hora iniciada: 20 × 40¢ = US$ 8,00.
A cobrança por hora custa 24 vezes mais pelos mesmos 50 minutos de trabalho na GPU. A saída óbvia é deixar uma única máquina ligada o dia todo. Oito horas a US$ 0,40 dão US$ 3,20, o que ganha dos US$ 8,00, mas ainda é 9,6 vezes a conta por segundo, porque agora você paga pelos intervalos entre os trabalhos.
Esse exemplo favorece a abordagem de instância nova, porque supõe que o trabalho começa no instante em que a máquina liga. Não é assim. Só para ilustrar, suponha que cada inicialização gaste 3 minutos subindo o sistema, baixando uma imagem e carregando um modelo antes de o trabalho começar (o seu número vai ser outro). A cobrança por segundo passa a ser de 20 × 330 s = 6.600 s, ou 73,33¢, mais que o dobro dos 33,33¢ de trabalho real. O incremento é o mesmo; o desperdício foi para a preparação.
No GPUFlow o mesmo dia fica um pouco diferente, porque o aluguel é reservado em horas inteiras e cobrado por segundo. Iniciar 20 aluguéis separados de 150 s custa ceil(150 × 40 / 3.600) = ceil(1,67) = 2¢ cada, ou seja, 40¢ no total. Arredondar cada aluguel para cima até o centavo inteiro acrescenta 0,33¢ por trabalho aqui, e é daí que vêm os 6,67¢ a mais em relação ao total por segundo. Se os trabalhos vierem concentrados, lembre do limite de 10 novos aluguéis por hora por usuário. Manter um único aluguel aberto o dia todo custa o tempo de relógio inteiro, 8 horas = US$ 3,20, porque o GPUFlow cobra por tempo, não por token.
O que importa mais do que o incremento
Quando os trabalhos passam de uns dez minutos, a diferença entre por segundo e por minuto é erro de arredondamento. Estas três coisas não são. Elas são tratadas com mais detalhe em quanto custa de verdade alugar uma GPU.
Tempo ocioso
Toda plataforma com cobrança por segundo cobra uma instância ligada, esteja a GPU trabalhando ou não. A documentação da Lambda diz isso com todas as letras: as instâncias são cobradas “estejam elas sendo usadas ativamente ou não”. O dia de trabalhos curtos acima mostra a escala: 50 minutos de trabalho, US$ 3,20 se a máquina ficar ligada por 8 horas. Nenhum incremento de cobrança resolve uma máquina que você esqueceu de desligar.
Tempo de preparação
Boot, download de imagens e de modelos: tudo acontece com o taxímetro rodando. A Lambda começa a cobrar quando a instância passa nas verificações de saúde, antes de o seu código fazer qualquer coisa. A cobrança por segundo não elimina esse custo; você o paga a cada inicialização.
Armazenamento com a máquina parada
Parar uma máquina geralmente para a cobrança da GPU. O disco continua sendo cobrado. O RunPod cobra o volume de um pod parado a US$ 0,20 por GB por mês, o dobro do preço com ele rodando, e a documentação avisa que “as cobranças de armazenamento continuam acumulando em Pods parados”. O Vast.ai diz claramente que “parar uma instância não evita os custos de armazenamento”. Um volume de 100 GB deixado num pod parado no RunPod custa 100 × US$ 0,20 = US$ 20 por mês, o equivalente a 50 horas de GPU a US$ 0,40.
Se a sua carga de trabalho são chamadas a um modelo, e não o seu próprio código rodando numa máquina, compare também com o preço por token: GPU por hora ou API por token mostra quando cada um sai mais barato.
Como o GPUFlow cobra: reserva primeiro, devolve o resto
O GPUFlow aluga inferência: você recebe uma chave de API compatível com a OpenAI para um modelo rodando na GPU de alguém, não uma máquina. Não há shell, disco nem imagem para pagar, então o armazenamento e a preparação da seção anterior não se aplicam. O tempo ocioso, sim: o aluguel é cobrado do início ao fim, com a GPU ocupada ou não.
Os passos são:
- Você escolhe um anúncio e um número inteiro de horas (de 1 a 168 por padrão). O preço por hora do provedor é convertido em centavos inteiros.
- No início, o valor total reservado sai dos seus créditos: preço em centavos × horas. É o valor inteiro, retido antecipadamente.
- Quando o aluguel termina, a cobrança é calculada uma única vez: segundos inteiros usados, no mínimo 60, vezes o preço em centavos, dividido por 3.600, arredondado para cima até o centavo seguinte e nunca acima da reserva.
- O que sobra da reserva volta para os seus créditos disponíveis no mesmo passo.
O formulário de aluguel mostra a reserva antes de você começar: 2 horas a US$ 0,35 reservam US$ 0,70.
Um exemplo com as contas
Reserve 3 horas a US$ 0,40. A reserva é de 40¢ × 3 = 120¢ (US$ 1,20). Você clica em Encerrar agora depois de 38 minutos e 20 segundos, ou seja, 2.300 segundos.
- Cobrança: ceil(2.300 × 40 / 3.600) = ceil(25,56) = 26¢.
- Devolvido aos seus créditos: 120 − 26 = 94¢.
- A taxa da plataforma é de 12% da cobrança, arredondada para o centavo mais próximo em cada aluguel: round(26 × 0,12) = round(3,12) = 3¢. O provedor recebe 26 − 3 = 23¢, que é 88,5% desta cobrança, e não exatamente 88%. Em cobranças maiores o arredondamento pesa menos.
Quando o aluguel termina sem você
Se as horas reservadas acabarem, uma rotina em segundo plano que roda a cada minuto fecha o aluguel. A cobrança é calculada até o horário de término reservado, então você não paga por nenhum atraso antes de a rotina rodar. A chave de API para de funcionar no horário de término. Se quiser mais tempo, Adicionar horas reserva mais créditos e mantém a mesma chave.
Se a máquina do provedor silenciar, o aluguel também termina. O agente na máquina do provedor envia um heartbeat a cada 15 segundos. Depois de 10 minutos sem nenhum, o aluguel é encerrado e cobrado só até o último heartbeat. A US$ 0,40 por hora, uma máquina que cai 25 minutos depois do início de uma reserva de 3 horas custa ceil(1.500 × 40 / 3.600) = 17¢, e os outros 103¢ da reserva de 120¢ voltam para você.
Há uma pegadinha entre a reserva em horas inteiras e o trabalho de 61 minutos. Se você reservar 1 hora e esquecer de clicar em Adicionar horas antes de ela acabar, a chave para aos 60 minutos e você paga 40¢ por um trabalho inacabado. Reserve 2 horas (80¢ reservados), encerre aos 61 minutos, e você paga 41¢ e recebe 39¢ de volta. Na dúvida, reserve mais e encerre antes; o tempo não usado não custa nada.
Como escolher o modelo de cobrança pelo formato do trabalho
- Muitos trabalhos de menos de 10 minutos: cobrança por segundo ou por minuto, e confira o mínimo. Qualquer coisa que arredonde para a hora é a ferramenta errada aqui.
- Trabalhos de 30 a 90 minutos: fuja do arredondamento para a hora cheia (um trabalho de 61 minutos paga duas horas). A diferença entre por segundo e por minuto vale menos de um centavo por trabalho.
- Execuções longas, de muitas horas: o incremento mal aparece. Olhe para o tempo ocioso, a preparação e o armazenamento.
- Chamadas em rajadas a um mesmo modelo ao longo do dia: uma máquina nova a cada rajada paga a preparação toda vez, e uma máquina sempre ligada paga pelos intervalos. Um aluguel de inferência que mantém o modelo pronto é uma forma de evitar a parte da preparação, mas o relógio continua correndo entre as chamadas, então ajuste a reserva ao horário em que você realmente trabalha.
Se quiser testar, o marketplace do GPUFlow lista os preços por hora de cada GPU, e o que você precisa para alugar uma GPU cobre a parte de conta e pagamento.
Fontes
- AWS, preços do Amazon EC2 On-Demand (detalhes de cobrança): aws.amazon.com/ec2/pricing/on-demand
- Google Cloud, preços de instâncias de VM (modelo de cobrança): cloud.google.com/compute/vm-instance-pricing
- Microsoft Azure, preços de máquinas virtuais Linux (FAQ): azure.microsoft.com/pricing/details/virtual-machines/linux
- Lambda, visão geral da cobrança: docs.lambda.ai/public-cloud/billing
- RunPod, preços de Pods: docs.runpod.io/pods/pricing
- Vast.ai, referência de cobrança: docs.vast.ai/documentation/reference/billing
- Documentação do GPUFlow, créditos, cobrança e reembolsos: docs.gpuflow.app/pt-br/renters/billing
Tudo verificado em setembro de 2026.