Modelo de Cobrança da Replicate

Replicate é uma plataforma para executar modelos de machine learning de código aberto na nuvem e um dos exemplos mais puros de precificação baseada em uso em IA. Não há assinatura mensal nem tarifa fixa por execução de modelo. A maioria dos modelos é cobrada pelo tempo de computação utilizado, medido por segundo, a uma tarifa que depende do hardware. Alguns modelos são cobrados com base na entrada e na saída, como por imagem ou por token (preços da Replicate). A cobrança por segundo é adequada para cargas de trabalho de IA porque os tempos de execução são imprevisíveis. Um usuário pode executar um modelo leve por alguns segundos, enquanto outro pode executar um modelo generativo grande por vários minutos. Como o preço acompanha a computação utilizada, e não o modelo, ele permanece transparente em qualquer escala.

Como a Replicate Cobra

A precificação baseada em tempo da Replicate não depende do modelo. Seja para gerar uma imagem com SDXL ou executar o Llama 3, a cobrança depende do nível de hardware e do tempo de execução. A Replicate pode hospedar milhares de modelos de código aberto sem um preço separado para cada um.

Hardware	Preço por segundo	Preço por hora
CPU	$0.000100	$0.36
NVIDIA T4 GPU	$0.000225	$0.81
NVIDIA L40S GPU	$0.000975	$3.51
NVIDIA A100 (80GB) GPU	$0.001400	$5.04
NVIDIA H100 GPU	$0.001525	$5.49

A implementação abaixo também usa medidores de exemplo para os níveis A40 e A100 (40GB), que a página de preços da Replicate não lista mais. Crie um medidor para cada nível de hardware que você oferece. Cada execução é medida no medidor correspondente ao hardware utilizado:

Tarifas específicas por hardware: o preço por segundo depende dos recursos de computação utilizados. Cada nível de hardware tem sua própria tarifa.
Modelo puramente baseado em uso: não há tarifas mensais, cotas incluídas nem excedentes. Os usuários pagam pelo tempo exato de computação, por exemplo, “12.4 segundos em um A100”, e não por geração.
Granularidade por segundo: provedores que cobram por hora ou minuto cobram pelo tempo não utilizado em tarefas curtas. A cobrança por segundo elimina esse desperdício tanto em pequenos experimentos quanto em grandes cargas de trabalho de produção.

Para modelos públicos, a Replicate cobra apenas pelo tempo em que um modelo está processando ativamente sua solicitação. A configuração (cold boot) e o tempo ocioso são gratuitos. Modelos privados e deployments são executados em hardware dedicado, portanto você paga por todo o tempo em que as instâncias ficam online: configuração, ociosidade e atividade (documentação de cobrança da Replicate).

O que torna isso único

Medição específica por hardware: o mesmo modelo custa mais em um hardware mais rápido, portanto os usuários equilibram velocidade e custo. Uma GPU T4 é adequada para tarefas que não são sensíveis ao tempo, enquanto uma A100 é adequada para aplicações em tempo real.
Granularidade por segundo: a cobrança é calculada por segundo, para que os usuários não paguem pelo tempo não utilizado em tarefas curtas.
Sem assinatura: os usuários começam sem compromisso, e o custo aumenta conforme o uso. Isso é adequado para startups e desenvolvedores que estão experimentando diferentes modelos.
Independente do modelo: a mesma lógica de cobrança se aplica à geração de imagens, ao processamento de texto, à transcrição de áudio e à síntese de vídeo. A plataforma oferece suporte a um amplo catálogo de modelos sem tabelas de preços complexas.

Crie isso com Dodo Payments

Você pode criar esse modelo com a cobrança baseada em uso do Dodo Payments. Crie um medidor por nível de hardware e associe todos eles a um único produto.

Create Usage Meters (One Per Hardware Class)

Crie um medidor separado para cada nível de hardware. Cada nível tem seu próprio preço por segundo, portanto medidores separados permitem que o Dodo Payments precifique cada nível e detalhe a fatura.

Nome do medidor	Nome do evento	Agregação	Propriedade
CPU Compute	`compute.cpu`	Soma	`execution_seconds`
GPU T4 Compute	`compute.gpu_t4`	Soma	`execution_seconds`
GPU A40 Compute	`compute.gpu_a40`	Soma	`execution_seconds`
GPU A40 Large Compute	`compute.gpu_a40_large`	Soma	`execution_seconds`
GPU A100 40GB Compute	`compute.gpu_a100_40`	Soma	`execution_seconds`
GPU A100 80GB Compute	`compute.gpu_a100_80`	Soma	`execution_seconds`

A agregação Soma sobre execution_seconds fornece o tempo total de computação por nível de hardware durante o período de cobrança.

Create a Usage-Based Product

Crie um produto no dashboard do Dodo Payments com estas configurações:

Tipo de preço: Cobrança baseada em uso
Preço base: $0/mês (sem tarifa de assinatura)
Frequência de cobrança: Mensal

Adicione cada medidor com seu preço por unidade:

Medidor	Preço por unidade (por segundo)
compute.cpu	$0.000100
compute.gpu_t4	$0.000225
compute.gpu_a40	$0.000575
compute.gpu_a40_large	$0.000725
compute.gpu_a100_40	$0.001150
compute.gpu_a100_80	$0.001400

Defina o Limite gratuito como 0 em todos os medidores, para que cada segundo de execução seja cobrável.

Send Usage Events

Envie um evento de uso ao Dodo Payments quando cada execução de modelo for concluída. Dê a cada previsão um event_id exclusivo, para que um evento repetido não seja contabilizado duas vezes.

import DodoPayments from 'dodopayments';

type HardwareTier = 'cpu' | 'gpu_t4' | 'gpu_a40' | 'gpu_a40_large' | 'gpu_a100_40' | 'gpu_a100_80';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

async function trackModelExecution(
  customerId: string,
  modelId: string,
  hardware: HardwareTier,
  executionSeconds: number,
  predictionId: string
) {
  const eventName = `compute.${hardware}`;

  await client.usageEvents.ingest({
    events: [{
      event_id: `pred_${predictionId}`,
      customer_id: customerId,
      event_name: eventName,
      timestamp: new Date().toISOString(),
      metadata: {
        execution_seconds: executionSeconds,
        model_id: modelId,
        hardware: hardware
      }
    }]
  });
}

// Example: SDXL image generation on A100
await trackModelExecution(
  'cus_abc123',
  'stability-ai/sdxl',
  'gpu_a100_80',
  8.3,  // 8.3 seconds of A100 time
  'pred_xyz789'
);

Measure Execution Time Precisely

Cronometre cada execução de modelo com performance.now() e arredonde para o décimo de segundo mais próximo para a cobrança.

// executeModel is your application's own function that runs the model.
async function runModelWithMetering(
  customerId: string,
  modelId: string,
  hardware: HardwareTier,
  input: Record<string, unknown>
) {
  const predictionId = `pred_${Date.now()}`;
  const startTime = performance.now();

  try {
    const result = await executeModel(modelId, input, hardware);
    const executionSeconds = (performance.now() - startTime) / 1000;
    const billedSeconds = Math.round(executionSeconds * 10) / 10;

    await trackModelExecution(
      customerId,
      modelId,
      hardware,
      billedSeconds,
      predictionId
    );

    return result;
  } catch (error) {
    // This example bills compute time for failed runs longer than 1 second.
    // Replicate doesn't charge for failed runs on public models; remove this block to match.
    const executionSeconds = (performance.now() - startTime) / 1000;
    if (executionSeconds > 1) {
      await trackModelExecution(
        customerId,
        modelId,
        hardware,
        Math.round(executionSeconds * 10) / 10,
        predictionId
      );
    }
    throw error;
  }
}

Create Checkout

Quando um usuário se cadastrar, crie uma sessão de checkout para o produto baseado em uso. O Dodo Payments então cobra o uso a cada ciclo e emite as faturas.

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_compute_payg', quantity: 1 }
  ],
  customer: { email: 'ml-engineer@example.com' },
  return_url: 'https://yourplatform.com/dashboard'
});

Acelere com o Time Range Ingestion Blueprint

O Time Range Ingestion Blueprint torna mais rápido o acompanhamento da computação por segundo. Crie uma instância de ingestão por nível de hardware e chame trackTimeRange após cada execução.

npm install @dodopayments/ingestion-blueprints

import { Ingestion, trackTimeRange } from '@dodopayments/ingestion-blueprints';

// Create one ingestion instance per hardware tier
function createHardwareIngestion(hardware: string) {
  return new Ingestion({
    apiKey: process.env.DODO_PAYMENTS_API_KEY,
    environment: 'live_mode',
    eventName: `compute.${hardware}`,
  });
}

const ingestions: Record<string, Ingestion> = {
  cpu: createHardwareIngestion('cpu'),
  gpu_t4: createHardwareIngestion('gpu_t4'),
  gpu_a40: createHardwareIngestion('gpu_a40'),
  gpu_a40_large: createHardwareIngestion('gpu_a40_large'),
  gpu_a100_40: createHardwareIngestion('gpu_a100_40'),
  gpu_a100_80: createHardwareIngestion('gpu_a100_80'),
};

// executeModel, modelId, input, hardware, and customerId come from your application.
const startTime = performance.now();
const result = await executeModel(modelId, input, hardware);
const durationMs = performance.now() - startTime;

await trackTimeRange(ingestions[hardware], {
  customerId: customerId,
  durationMs: durationMs,
  metadata: {
    model_id: modelId,
    hardware: hardware,
  },
});

O blueprint cria e envia o evento, com a duração como durationMs nos metadados. Defina o Over Property de cada medidor como durationMs ou envie durationSeconds para manter a precificação por segundo. Com uma instância de ingestão por nível de hardware, isso corresponde diretamente à medição em vários níveis da Replicate.

Para jobs de longa duração, combine o Time Range Blueprint com o acompanhamento de heartbeat baseado em intervalos, apresentado em Avançado: Medição por heartbeat. Consulte a documentação completa do blueprint para ver mais padrões.

Estimativa de custos para usuários

As cobranças baseadas em uso podem ser difíceis de prever, portanto mostre aos usuários uma estimativa de custo antes que executem um modelo. As estimativas evitam cobranças inesperadas e aumentam a confiança.

Exemplos de cálculos de custo

Modelo	Hardware	Tempo médio	Custo por execução
SDXL (imagem)	A100 80GB	~8 s	~$0.0112
Llama 3 (texto)	A100 40GB	~3 s	~$0.0035
Whisper (áudio)	GPU T4	~15 s	~$0.0034

Criando uma calculadora de custos

Esta função multiplica a tarifa por segundo do nível pelo tempo de execução estimado:

function estimateCost(hardware: HardwareTier, estimatedSeconds: number): number {
  const rates: Record<HardwareTier, number> = {
    'cpu': 0.000100,
    'gpu_t4': 0.000225,
    'gpu_a40': 0.000575,
    'gpu_a40_large': 0.000725,
    'gpu_a100_40': 0.001150,
    'gpu_a100_80': 0.001400
  };

  return Number((rates[hardware] * estimatedSeconds).toFixed(4));
}

// Show the user before running: "This will cost approximately $0.0119"
const estimate = estimateCost('gpu_a100_80', 8.5);

Enterprise: capacidade reservada

Para clientes que precisam de capacidade dedicada e nenhum cold boot, a Replicate oferece deployments: instâncias dedicadas cobradas por todo o tempo em que permanecem online. Para representar a capacidade reservada com o Dodo Payments, venda-a como um produto de assinatura:

Tipo de produto: Assinatura
Preço: preço mensal fixo (por exemplo, “Instância A100 reservada - $500/mês”)
Ciclo de cobrança: Mensal

Você ainda pode enviar eventos de uso para monitoramento e analytics, enquanto a assinatura cobre o custo. À medida que o volume de um cliente aumenta, a capacidade reservada geralmente custa menos do que o modelo pay-as-you-go.

Avançado: medição por heartbeat

Para tarefas executadas por minutos ou horas, um único evento ao final é arriscado: se o processo falhar, você perderá os dados de uso. Em vez disso, envie um evento de uso a cada 30 a 60 segundos enquanto a tarefa estiver em execução.

// executeLongTask is your application's own function. trackModelExecution is defined above.
async function runLongTaskWithHeartbeat(
  customerId: string,
  modelId: string,
  hardware: HardwareTier
) {
  const predictionId = `pred_${Date.now()}`;
  let totalSeconds = 0;

  const heartbeatInterval = setInterval(async () => {
    try {
      await trackModelExecution(
        customerId,
        modelId,
        hardware,
        30,
        `${predictionId}_${totalSeconds}`
      );
      totalSeconds += 30;
    } catch (error) {
      console.error('Heartbeat tracking failed:', error, { predictionId, totalSeconds });
    }
  }, 30000);

  try {
    await executeLongTask();
  } finally {
    clearInterval(heartbeatInterval);
  }
}

Principais recursos do Dodo utilizados

Usage-Based Billing

Configure produtos que cobram com base no consumo.

Meters

Defina as métricas que você deseja acompanhar e pelas quais deseja cobrar.

Event Ingestion

Envie dados de uso ao Dodo Payments conforme eles ocorrerem.

Subscriptions

Gerencie a cobrança recorrente de capacidade reservada e planos Enterprise.

Time Range Blueprint

Acompanhe a computação por segundo com auxiliares de duração.

Integration Guides

Billing Deconstructions

Cookbooks

Como a Replicate Cobra

O que torna isso único

Crie isso com Dodo Payments

Acelere com o Time Range Ingestion Blueprint

Estimativa de custos para usuários

Exemplos de cálculos de custo

Criando uma calculadora de custos

Enterprise: capacidade reservada

Avançado: medição por heartbeat

Principais recursos do Dodo utilizados

Usage-Based Billing

Meters

Event Ingestion

Subscriptions

Time Range Blueprint

​Como a Replicate Cobra

​O que torna isso único

​Crie isso com Dodo Payments

​Acelere com o Time Range Ingestion Blueprint

​Estimativa de custos para usuários

​Exemplos de cálculos de custo

​Criando uma calculadora de custos

​Enterprise: capacidade reservada

​Avançado: medição por heartbeat

​Principais recursos do Dodo utilizados

Usage-Based Billing

Meters

Event Ingestion

Subscriptions

Time Range Blueprint

Como a Replicate Cobra

O que torna isso único

Crie isso com Dodo Payments

Acelere com o Time Range Ingestion Blueprint

Estimativa de custos para usuários

Exemplos de cálculos de custo

Criando uma calculadora de custos

Enterprise: capacidade reservada

Avançado: medição por heartbeat

Principais recursos do Dodo utilizados