Midjourney Billing Model

​

How Midjourney Bills

1. Pricing Tiers: Midjourney erbjuder fyra prenumerationsnivåer från $10 till $120 per månad, där varje nivå ger ett fast antal Fast GPU-timmar.
2. Relax Mode: Standard- och högre planer inkluderar obegränsade generationer via en lågprioriterad kö när Fast-timmar är slut, vilket säkerställer att användare aldrig stöter på en hård gräns.
3. Extra GPU Hours: Användare kan köpa ytterligare Fast GPU-tid för ungefär $4 per timme om de behöver omedelbara resultat efter att ha uttömt sin månatliga kvot.
4. Metering in GPU Seconds: Användningen spåras av den faktiska beräkningstiden som spenderas på generationer, vilket innebär att komplexa renderingar kostar mer än enkla utkast.
5. Community Loop: Aktiva användare kan tjäna bonus GPU-timmar genom att betygsätta bilder i galleriet, vilket hjälper till att träna modeller samtidigt som det belönar communityn.

​

What Makes It Unique

• GPU-time billing kopplar kostnad till resursanvändning och säkerställer att komplexa renderingar prissätts rätt jämfört med enkla utkast.
• Relax Mode erbjuder en obegränsad fallback som minskar churn genom att upprätthålla åtkomst till tjänsten även efter att månatliga gränser nåtts.
• The Fast vs Relax split uppmuntrar uppgraderingar genom att erbjuda prioriterad bearbetning för användare som värdesätter snabbhet och omedelbara resultat.
• Extra GPU Hours ger ett flexibelt påfyllningsalternativ för kraftanvändare som behöver extra högprioriterad kapacitet mitt i månaden.

​

Build This with Dodo Payments

async function handleGenerationRequest(customerId: string, prompt: string) {
  const usage = await getCustomerUsage(customerId, 'gpu.fast_seconds');
  const subscription = await getSubscription(customerId);
  const threshold = getThresholdForPlan(subscription.product_id);
  
  if (usage.current >= threshold) {
    if (subscription.product_id === 'prod_basic') {
      throw new Error('Fast GPU hours exhausted. Upgrade to Standard for Relax Mode.');
    }
    
    // Relax Mode. Route to low-priority queue
    return await queueGeneration(customerId, prompt, {
      priority: 'low',
      mode: 'relax',
      model: 'standard'
    });
  }
  
  // Fast Mode. Priority processing
  return await queueGeneration(customerId, prompt, {
    priority: 'high',
    mode: 'fast',
    model: 'premium'
  });
}

import DodoPayments from 'dodopayments';

async function trackFastGeneration(customerId: string, gpuSeconds: number, jobId: string) {
  // Only track Fast mode generations. Relax mode is free and unlimited
  const client = new DodoPayments({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  });

  await client.usageEvents.ingest({
    events: [{
      event_id: `gen_${jobId}`,
      customer_id: customerId,
      event_name: 'gpu.fast_seconds',
      timestamp: new Date().toISOString(),
      metadata: {
        gpu_seconds: gpuSeconds,
        resolution: '1024x1024',
        mode: 'fast'
      }
    }]
  });
}

// After customer purchases extra hours
const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'prod_extra_gpu_hour', quantity: 5 }
  ],
  customer: { customer_id: customerId },
  return_url: 'https://yourapp.com/dashboard'
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'prod_mj_standard', quantity: 1 }
  ],
  customer: { email: 'artist@example.com' },
  return_url: 'https://yourapp.com/studio'
});

​

Accelerate with the Time Range Ingestion Blueprint

npm install @dodopayments/ingestion-blueprints

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

const ingestion = new Ingestion({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'gpu.fast_seconds',
});

// Track generation time after a Fast mode job completes
const startTime = Date.now();
const result = await runGeneration(prompt, settings);
const durationMs = Date.now() - startTime;

await trackTimeRange(ingestion, {
  customerId: customerId,
  durationMs: durationMs,
  metadata: {
    mode: 'fast',
    resolution: '1024x1024',
  },
});

​

The Fast vs Relax Architecture

1. Alla förfrågningar går genom din applikation.
2. Applikationen jämför Dodo-nytto mätaren med planens fria tröskel.
3. Om användningen är under tröskeln går förfrågan till Fast-kön och mäts.
4. Om användningen är över tröskeln går förfrågan till Relax-kön, som inte mäts och har lägre prioritet.
5. Basic-planen har ingen Relax-fallback, så förfrågningar blockeras när gränsen nås.

​

Key Dodo Features Used