# How Midjourney Handles Billing: A Complete Breakdown > A deep analysis of Midjourney's GPU-time subscription model - from fast hour allocations and Relax Mode to tiered pricing and how to build the same billing system for your own AI product. - **Author**: Ayush Agarwal - **Published**: 2026-04-09 - **Category**: AI, Billing - **URL**: https://dodopayments.com/blogs/midjourney-billing-model --- Most AI tools bill per request or per token. Midjourney does something different. It bills based on GPU time - the actual computational seconds spent rendering your images. A quick low-resolution draft costs a fraction of what a complex high-resolution upscale does, because the GPU works harder and longer on the latter. This creates a billing model that sits between [subscription pricing](https://dodopayments.com/blogs/subscription-pricing-models) and [usage-based billing](https://dodopayments.com/blogs/usage-based-billing-saas). Users pay a fixed monthly fee that includes a pool of "fast GPU hours." When those hours run out, higher-tier subscribers fall back to Relax Mode - unlimited but slower generations. The result is a system where nobody gets cut off mid-workflow, but power users are nudged toward larger plans. This post breaks down how Midjourney's billing works, what makes it effective, where it creates friction, and how you can build the same GPU-time billing model using [Dodo Payments](https://dodopayments.com). For a full technical implementation guide with code, see the [Midjourney Billing Deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/midjourney) in Dodo's documentation. ## Midjourney's Pricing Tiers Midjourney offers four subscription plans. All plans grant access to the same models and features - the differences come down to fast GPU hours, queue priority, and privacy features. | Plan | Monthly Price | Annual Price | Fast GPU Hours | Relax Mode | Stealth Mode | | :------- | :------------ | :----------- | :------------- | :--------- | :----------- | | Basic | $10/month | $8/month | ~3.3 hours | No | No | | Standard | $30/month | $24/month | 15 hours | Unlimited | No | | Pro | $60/month | $48/month | 30 hours | Unlimited | Yes | | Mega | $120/month | $96/month | 60 hours | Unlimited | Yes | A few things stand out about this structure. **The billing unit is GPU time, not image count.** Midjourney does not sell "200 images per month." It sells 3.3 hours (or 15, 30, 60) of GPU processing time. A simple 512x512 generation might take 10 seconds of GPU time. A detailed 1024x1024 render with multiple variations could take 60+ seconds. This means the same plan can produce vastly different numbers of images depending on how you use it. **Relax Mode is the retention mechanic.** Starting from the Standard plan, users who exhaust their fast hours get unlimited access to a lower-priority queue. Generations still work - they just take 2-10 minutes instead of 30-60 seconds. This prevents the hard cutoff that causes churn in strict [metered billing](https://dodopayments.com/blogs/metered-billing-gpt-wrapper) models. **Stealth Mode is the enterprise hook.** Pro and Mega subscribers can generate images privately, keeping them out of the public gallery. For agencies, brands, and commercial creators working on unreleased campaigns, this privacy feature alone justifies the higher tiers. **Annual billing offers 20% savings.** The annual discount follows standard SaaS convention, reducing the effective monthly cost from $10 to $8 on Basic and from $120 to $96 on Mega. ## How Midjourney's Billing Actually Works Under the hood, Midjourney runs a hybrid system: fixed subscription fees combined with GPU-time metering and application-level queue routing. Understanding each layer explains why the model works. ### GPU Seconds as the Billing Unit Every image generation on Midjourney consumes GPU time measured in seconds. The platform tracks this continuously and deducts from the user's monthly allocation. Several factors affect how much GPU time a single generation costs: - **Resolution**: Higher resolution outputs require more rendering passes - **Model version**: Newer models (V6, V7, V8) have different computational profiles - **Variations and upscales**: Each variation or upscale is a separate GPU job - **Prompt complexity**: Detailed prompts with multiple subjects take longer to resolve This is fundamentally different from billing per "image" or per "request." A user generating 100 simple thumbnails uses far less GPU time than someone rendering 20 detailed poster-quality images. The billing reflects actual resource consumption rather than arbitrary unit counts. > The best billing models charge based on the value delivered, not the action taken. GPU-time billing works for AI image generation because a 60-second render genuinely produces more value than a 5-second draft. > > - Ayush Agarwal, Co-founder & CPTO at Dodo Payments ### The Fast vs. Relax Queue System Midjourney operates two parallel processing queues that define the user experience after fast hours run out. ```mermaid flowchart TD A["Generation Request"] --> B{"Fast Hours Remaining?"} B -->|"Yes"| C["Fast Queue"] C --> D["Priority GPU Processing 30-60 seconds"] D --> E["Deduct GPU Seconds from Monthly Pool"] B -->|"No"| F{"Plan Includes Relax Mode?"} F -->|"Yes - Standard/Pro/Mega"| G["Relax Queue"] G --> H["Low Priority Processing 2-10 minutes"] F -->|"No - Basic"| I["Generation Blocked"] I --> J["Prompt to Upgrade"] ``` The Fast Queue delivers results in 30-60 seconds and consumes the user's fast hour allocation. Once that pool is depleted, the system checks the user's plan: - **Standard, Pro, Mega**: Requests route to the Relax Queue. Generations are unlimited but run on lower-priority GPU capacity, taking 2-10 minutes depending on platform load. - **Basic**: Requests are blocked. The user must wait until next month's allocation resets or purchase extra fast hours. This dual-queue architecture is what makes Midjourney's billing work. It prevents the hard usage wall that frustrates users while maintaining clear incentives to upgrade. A Standard user who consistently runs out of fast hours and finds Relax Mode too slow has a natural reason to move to Pro. ### Extra GPU Hours Users who need more fast processing can purchase additional GPU hours at approximately $4 per hour. This is a straightforward top-up that adds to the current month's fast pool without changing the subscription tier. The $4/hour price point is notable because it is more expensive per hour than any subscription tier on a per-hour basis. Basic plan users pay roughly $3 per fast hour ($10 for 3.3 hours). Mega users pay $2 per hour ($120 for 60 hours). The premium on extra hours discourages relying on top-ups and incentivizes choosing the right plan size. ### Community Rating Rewards Midjourney includes a unique engagement mechanic: users can earn bonus GPU hours by rating images in the community gallery. This crowdsourced feedback loop trains their models while rewarding active community members with additional fast time. It is a clever way to reduce data labeling costs while increasing platform stickiness. ## What Makes Midjourney's Billing Effective Midjourney's GPU-time model solves several problems that plague other [AI billing platforms](https://dodopayments.com/blogs/ai-billing-platforms). ### Cost-to-Value Alignment Billing by GPU seconds means the price a user pays correlates directly with the computational resources consumed. A complex multi-subject scene at high resolution costs more because it genuinely requires more GPU work. This feels fair to users because they can see the relationship between what they asked for and what they were charged. Compare this to flat per-image pricing, where a 5-second thumbnail costs the same as a 60-second cinematic render. The [usage-based model](https://dodopayments.com/blogs/usage-based-pricing-examples) eliminates that subsidy problem. ### Soft Caps Reduce Churn The Relax Mode fallback is arguably the most important billing design decision. In traditional [metered billing](https://dodopayments.com/blogs/implement-usage-based-billing), exceeding your allocation means either getting cut off or paying overage fees. Both options create negative experiences. Midjourney's approach degrades performance (speed) without removing access. Users still get their images - they just wait longer. This preserves the core value proposition even when the paid allocation runs out. For products where users are in the middle of a creative flow, this matters enormously. Nobody wants to hit a billing wall at 2 AM when finishing a client project. ### Natural Upgrade Incentives The tier structure creates organic upgrade pressure without aggressive upselling. Consider the progression: - **Basic to Standard**: The jump from 3.3 to 15 hours plus Relax Mode is massive. Most users who exceed Basic limits find Standard to be an obvious upgrade. - **Standard to Pro**: Double the fast hours plus Stealth Mode. Users doing commercial work where privacy matters have a clear reason to upgrade. - **Pro to Mega**: Double again. Only needed by teams or power users who consistently burn through 30 hours. Each tier upgrade doubles the fast hours while only doubling the price (except Basic to Standard, which is 3x price for 4.5x hours). This makes the value proposition improve at higher tiers, rewarding commitment rather than penalizing volume. The pattern follows what works in [tiered pricing](https://dodopayments.com/blogs/tiered-pricing-model-guide) broadly: give more value per dollar as users move up. ### Predictable Revenue with Usage Flexibility From Midjourney's business perspective, the fixed subscription base provides predictable monthly revenue. Usage variance is absorbed by the Relax Queue, which runs on spare GPU capacity that would otherwise go idle. The extra hours purchases add incremental revenue from power users without requiring plan changes. This is the same hybrid pattern that other AI companies like [Cursor](https://dodopayments.com/blogs/cursor-billing-model) and [OpenAI](https://dodopayments.com/blogs/openai-billing-model) use - a subscription floor with usage-based components on top. The difference is that Midjourney's "usage" is measured in time rather than tokens or credits. ## Where Midjourney's Billing Creates Friction No billing model is perfect. Midjourney's GPU-time approach introduces specific challenges that users and competitors have noted. ### GPU Time Is Hard to Predict Users cannot easily estimate how many images their fast hours will produce. A 3.3-hour allocation on Basic could yield anywhere from 200 to 600 images depending on resolution, model version, and prompt complexity. This ambiguity makes it difficult for new users to choose the right plan. Token-based billing (like OpenAI's API) has the same problem, but at least tokens map roughly to word count. GPU seconds have no intuitive equivalent. The lack of a clear [usage cap or alert system](https://dodopayments.com/blogs/billing-ux-usage-caps-alerts) visible to users before they start a generation makes budget management harder. ### Basic Plan Is Severely Limited At 3.3 fast hours with no Relax Mode fallback, the Basic plan functions more as a trial than a sustainable tier. Most active users will exhaust their allocation within a few days. The hard cutoff after fast hours run out - with no option to continue at reduced speed - creates a frustrating cliff that pushes users toward the 3x-priced Standard plan. The gap between $10 and $30 is where Midjourney loses casual users who want more than Basic but cannot justify Standard. ### Relax Mode Speed Is Unpredictable Relax Mode processing times range from 2 to 10 minutes depending on platform demand. During peak hours, waits can stretch even longer. There is no SLA or guaranteed maximum wait time. For users who rely on Relax Mode as a core part of their workflow, this unpredictability can be disruptive. It makes capacity planning for professional use cases unreliable compared to [flat-fee models](https://dodopayments.com/blogs/usage-based-billing-vs-flat-fees-ai-saas) with consistent performance. ### No API-Level Billing Midjourney does not currently offer a standalone API with separate usage-based pricing for developers building on top of the platform. All billing goes through the subscription tiers. This limits Midjourney's addressable market. Developers building AI art applications, design automation tools, or batch processing workflows cannot integrate Midjourney into their [billing infrastructure](https://dodopayments.com/blogs/billing-infrastructure-age-ai-agents) the way they can with OpenAI or Stability AI. ## Build a GPU-Time Billing Model with Dodo Payments You can replicate Midjourney's exact billing architecture using [Dodo Payments](https://dodopayments.com). The setup combines [subscriptions](https://docs.dodopayments.com/features/subscription) with [usage-based billing](https://docs.dodopayments.com/features/usage-based-billing/introduction) and application-level queue routing for the Relax Mode fallback. For the complete step-by-step implementation, see the [Midjourney Billing Deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/midjourney) in Dodo's documentation. Here is a summary of the key components. ### Step 1: Create a GPU Time Meter Set up a usage meter to track fast GPU seconds consumed by each customer. ```typescript // Meter configuration in Dodo dashboard: // Name: gpu.fast_seconds // Aggregation: Sum (sums the gpu_seconds property from each event) // Only fast mode generations are metered. Relax mode is free. ``` The meter aggregates the `gpu_seconds` property from incoming events using a Sum aggregation. This gives you a running total of fast GPU time consumed per customer per billing cycle. ### Step 2: Create Subscription Products with Usage Thresholds Each subscription tier maps to a Dodo product with a base price and a free usage threshold: | Product | Base Price | Free Threshold (seconds) | Overage Behavior | | :------- | :--------- | :----------------------- | :------------------ | | Basic | $10/month | 12,000 (3.3 hrs) | Hard cap - blocked | | Standard | $30/month | 54,000 (15 hrs) | Relax Mode fallback | | Pro | $60/month | 108,000 (30 hrs) | Relax Mode fallback | | Mega | $120/month | 216,000 (60 hrs) | Relax Mode fallback | The free threshold defines how many GPU seconds are included before the plan's behavior changes. For Basic, exceeding the threshold blocks further fast generations. For Standard and above, your application routes requests to the Relax Queue instead. ### Step 3: Implement Queue Routing with Usage Checks The core billing logic checks the Dodo usage meter against the plan threshold to decide whether a generation runs in fast or relax mode: ```typescript 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.", ); } // Route to Relax Queue - unmetered, lower priority return await queueGeneration(customerId, prompt, { priority: "low", mode: "relax", model: "standard", }); } // Fast Queue - metered, priority processing return await queueGeneration(customerId, prompt, { priority: "high", mode: "fast", model: "premium", }); } ``` Relax Mode is not a billing feature. It is an application-level routing decision. Dodo tracks usage and tells you when the threshold is exceeded. Your application decides whether to block the user (Basic) or route them to a slower queue (Standard+). ### Step 4: Send Usage Events for Fast Generations Only fast mode generations are metered. Relax mode is unlimited and free, so those events are not sent to Dodo. ```typescript import DodoPayments from "dodopayments"; async function trackFastGeneration( customerId: string, gpuSeconds: number, jobId: string, ) { 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", }, }, ], }); } ``` Each event includes the GPU seconds consumed and metadata about the generation. Dodo's [event ingestion system](https://docs.dodopayments.com/features/usage-based-billing/event-ingestion) handles deduplication via the `event_id`, so retries are safe. ### Step 5: Handle Top-Up Purchases For the "Extra Fast Hours" feature, create a one-time payment product priced at $4 per hour. When purchased, your application adds the equivalent seconds to the customer's threshold for the current billing cycle: ```typescript 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", }); ``` Use [webhooks](https://docs.dodopayments.com/developer-resources/webhooks) to listen for the payment completion event and credit the additional GPU hours to the customer's account. ## Midjourney's Model in Context Midjourney's GPU-time billing represents one approach to a challenge every AI product faces: how to charge for variable-cost computational resources without alienating users. The subscription-plus-metering hybrid is becoming the default pattern across the industry. [OpenAI uses token-based metering](https://dodopayments.com/blogs/openai-billing-model) with prepaid credits for API access and flat subscriptions for ChatGPT. [Cursor uses dollar-denominated credit pools](https://dodopayments.com/blogs/cursor-billing-model) with model-weighted deductions. Midjourney uses GPU-time with a dual-queue fallback. Each approach optimizes for different user expectations, but all share the same underlying architecture: a [subscription base that covers predictable revenue](https://dodopayments.com/blogs/subscriptions-usage-based-billing-saas), layered with usage tracking that scales with actual consumption. The GPU-time approach works particularly well for image generation because the computational cost of each generation varies significantly based on output parameters. It would not work as well for a chatbot where response times are relatively uniform. Choosing the right billing unit for your specific product - whether that is tokens, API calls, GPU seconds, or something else - is the first and most consequential [billing architecture decision](https://dodopayments.com/blogs/best-saas-billing-infra) you will make. ## FAQ ### Does Midjourney charge per image or per GPU hour? Midjourney charges per GPU time, not per image. Each subscription tier includes a set number of fast GPU hours (3.3 to 60 hours depending on the plan). The actual number of images you can generate depends on resolution, model version, and prompt complexity. A simple low-resolution image might use 10 seconds of GPU time, while a complex high-resolution render could use 60+ seconds. ### What happens when you run out of fast hours on Midjourney? It depends on your plan. Standard, Pro, and Mega subscribers fall back to Relax Mode, which provides unlimited generations at lower priority (2-10 minute wait times instead of 30-60 seconds). Basic plan users are blocked from generating until the next billing cycle or until they purchase extra fast hours at roughly $4 per hour. ### Can you build a Midjourney-style billing model for your own AI product? Yes. The core components are a subscription for the base plan, a usage meter tracking GPU seconds (or your equivalent billing unit), and application-level queue routing for the fast/relax split. [Dodo Payments](https://dodopayments.com) supports all three natively. See the [Midjourney billing deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/midjourney) for a complete implementation guide. ### How does Midjourney's billing compare to OpenAI or Cursor? All three use subscription-plus-usage hybrids, but with different billing units. OpenAI meters tokens (words processed). Cursor meters dollar-equivalent credits weighted by model cost. Midjourney meters GPU seconds (actual compute time). Midjourney's approach is the most resource-aligned of the three, since it directly reflects infrastructure cost. However, GPU seconds are harder for users to predict than tokens or credits. ### Is Midjourney's annual billing worth it? Annual billing saves 20% across all tiers, reducing Basic from $10 to $8/month and Mega from $120 to $96/month. If you have been using Midjourney consistently for 2-3 months and expect continued use, the annual commitment pays for itself by the tenth month. The savings compound at higher tiers - Mega subscribers save $288 per year. ## Final Take Midjourney's GPU-time billing works because it solves the fundamental mismatch between fixed pricing and variable compute costs. Charging by GPU seconds ensures that a quick draft and a complex render are priced proportionally to their actual resource consumption. The Relax Mode fallback prevents the hard usage walls that drive churn in strict metered systems. If you are building an AI product with similar compute-cost variability - image generation, video rendering, audio synthesis, or any GPU-intensive workload - the same architecture applies. Start with [subscription tiers](https://dodopayments.com/blogs/set-up-subscription-billing-afternoon) that include usage thresholds, add [metered billing](https://dodopayments.com/blogs/best-billing-platform-usage-based-pricing) for the variable component, and implement application-level fallback behavior for when users exceed their allocation. The [billing infrastructure](https://dodopayments.com/blogs/billing-automation-saas) should handle the metering and subscription logic so you can focus on the product. Check out [Dodo Payments](https://dodopayments.com) to build this for your product, or explore the [pricing page](https://dodopayments.com/pricing) to see the rates. --- - [More AI articles](https://dodopayments.com/blogs/category/ai) - [All articles](https://dodopayments.com/blogs)