Our team's quantitative analysis of Midjourney's newly released v6 API reveals a significant and detrimental regression in permissible request rates compared to the v5.2 infrastructure. We have transitioned three separate content generation pipelines (product prototyping, marketing asset creation, and concept art iteration) to the v6 API endpoints, and in all cases, we are encountering systematic workflow interruptions due to HTTP 429 "Too Many Requests" responses. The effective rate limit appears to be far more aggressive than documented, and the lack of transparent, configurable quotas is causing substantial drops in our throughput metrics.
Our standardized benchmark, designed to simulate a typical user workflow, involves a burst of 10 generation requests followed by a sustained queue of 2 requests per minute. Under v5.2, this pattern completed with a 100% success rate over a 60-minute test window. The same exact test pattern against the v6 API fails consistently. The failure mode is not purely request-per-minute (RPM) based; it seems to incorporate a stricter concurrent request limit and a surprisingly low hourly ceiling.
Our current logging shows the following error distribution:
```
Time Window: 1 hour
Total Requests Attempted: 85
Successful Completions: 47 (55.3%)
429 Errors: 38 (44.7%)
Median Latency for Successful Requests: 12.4 seconds
95th Percentile Latency: 31.7 seconds
```
The immediate consequence is a doubling of job completion time for batches exceeding 20 images, as we are forced to implement increasingly complex exponential backoff and job reprioritization logic.
We have attempted several client-side mitigations with measured outcomes:
* **Exponential Backoff with Jitter:** Implemented a standard `baseDelay * (2^attempt) + random_milliseconds` strategy. Outcome: Reduces error count but collapses overall throughput by over 60%, making it economically non-viable for our scale.
* **Request Queue & Throttling:** Built a priority queue system that strictly enforces a 15-second interval between dispatches. Outcome: Eliminates 429 errors but reveals the latency variance of the API itself now becomes the bottleneck, with queue backlogs forming during peak usage hours.
* **Multiple API Keys & Load Distribution:** We attempted to segment workflows across multiple paid accounts. Outcome: This is effective but multiplies cost linearly, destroying our carefully calculated cost-per-image metric. It also violates the terms of service for team-based automation.
My primary question for the community is whether anyone has conducted a rigorous, reproducible reverse-engineering of the v6 API's rate limiting algorithm? We need to understand if it is:
1. A strict token-bucket algorithm (and what its `capacity` and `refill_rate` are).
2. A sliding window limit.
3. A hybrid model incorporating factors like total pixel area (steps * dimensions), concurrent prompt similarity, or account spending tier.
Furthermore, are there any server-side or workflow adjustments—such as specific parameters in the `--style` or `--chaos` flags—that inadvertently consume more "rate limit budget"? Has anyone successfully negotiated a formal rate limit increase with Midjourney support for a commercial plan, and if so, what was the process and outcome?
Without clear documentation, we are left empirically testing limits, which is inefficient and risks service disruption. Sharing aggregated, anonymized data on successful patterns would benefit all developers building on this platform.
numbers don't lie.
numbers don't lie