adobe-rate-limits

Implement Adobe API rate limiting, backoff, and quota management across Firefly, PDF Services, Photoshop, and I/O Events APIs. Use when handling rate limit errors, implementing retry logic, or optimizing API request throughput for Adobe. Trigger with phrases like "adobe rate limit", "adobe throttling", "adobe 429", "adobe retry", "adobe backoff", "adobe quota".

Jump to install

Repository: jeremylongshore/tons-of-skills-marketplace
Last source activity: August 24, 2026 at 23:05
Detected SKILL.md language: English
Stars: 2,677
Forks: 392

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

Back to search Back to installation

name	adobe-rate-limits
description	Implement Adobe API rate limiting, backoff, and quota management across Firefly, PDF Services, Photoshop, and I/O Events APIs. Use when handling rate limit errors, implementing retry logic, or optimizing API request throughput for Adobe. Trigger with phrases like "adobe rate limit", "adobe throttling", "adobe 429", "adobe retry", "adobe backoff", "adobe quota".
allowed-tools	Read, Write, Edit
version	1.7.0
license	MIT
author	Jeremy Longshore <jeremy@intentsolutions.io>
tags	["saas","design","adobe"]
compatibility	Designed for Claude Code

Adobe Rate Limits

Overview

Handle Adobe API rate limits gracefully with exponential backoff, Retry-After header support, and proactive quota management. Each Adobe API has different rate limits.

Prerequisites

Adobe SDK installed and authenticated
Understanding of async/await patterns
Awareness of your API tier and entitlements

Instructions

Step 1: Know Your Rate Limits by API

API	Limit	Scope	Response
Firefly API	~20 req/min (trial), higher on paid	Per api-key	`429` + `Retry-After`
PDF Services	500 tx/month (free), unlimited (paid)	Per credential	`429` or `QUOTA_EXCEEDED`
Photoshop API	Varies by entitlement	Per api-key	`429` + `Retry-After`
Lightroom API	Varies by entitlement	Per api-key	`429` + `Retry-After`
I/O Events Publishing	3,000 req/5sec	Per api-key	`429` + `Retry-After`
Analytics 2.0 API	12 req/6sec per user (~120 req/min)	Per user	`429` + `Retry-After`
IMS Token Endpoint	~100 req/min	Per client_id	`429`

Step 2: Implement Retry-After Aware Backoff

// src/adobe/rate-limiter.ts
import { AdobeApiError } from './client';

export async function withAdobeBackoff<T>(
  :  <T>,
  config = { : , : , :  }
): <T> {
   ( attempt = ; attempt <= config.; attempt++) {
     {
        ();
    }  (: ) {
       (attempt === config.)  error;

      
       status = error. || error.?.;
       (status && status !==  && (status <  || status >= ))  error;

      
       : ;
       (error.) {
        delay = error. * ;
      }  {
        
         exponential = config. * .(, attempt);
         jitter = .() * config.;
        delay = .(exponential + jitter, config.);
      }

      .(
         +
        
      );
        ( (r, delay));
    }
  }
    ();
}

// Track remaining quota from response headers
class AdobeRateTracker {
  private remaining: number = Infinity;
  private resetAt: number = 0;

  updateFromResponse(response: Response): void {
    const remaining = response.headers.get('Retry-After');
    // Adobe primarily uses Retry-After rather than X-RateLimit-* headers
    // Some APIs (Analytics, Events) include additional rate info
    if (remaining) {
      this.remaining = 0;
      this.resetAt = Date.now() + parseInt(remaining) * 1000;
    }
  }

  async waitIfNeeded(): Promise<void> {
    if (this.remaining <= 0 && Date.now() < this.resetAt) {
      const waitMs = this.resetAt - Date.now();
      console.log(`Proactively waiting ${waitMs}ms for Adobe rate limit reset`);
      await new Promise(r => setTimeout(r, waitMs));
      this.remaining = Infinity; // Reset after wait
    }
  }
}

import PQueue from 'p-queue';

// Configure queue per API — match to known rate limits
const fireflyQueue = new PQueue({
  concurrency: 2,        // Max concurrent requests
  interval: 3000,        // Time window (ms)
  intervalCap: 1,        // Max requests per interval
});

const pdfServicesQueue = new PQueue({
  concurrency: 5,
  interval: 1000,
  intervalCap: 5,
});

const eventsQueue = new PQueue({
  concurrency: 10,
  interval: 5000,
  intervalCap: 3000,     // Match Adobe's 3000/5sec limit
});

// Usage
async function batchFireflyGenerate(prompts: string[]) {
  const results = await Promise.all(
    prompts.map(prompt =>
      fireflyQueue.add(() =>
        withAdobeBackoff(() => generateImage({ prompt }))
      )
    )
  );
  return results;
}

// Track monthly PDF Services usage against free tier limit
class PdfServicesQuotaTracker {
  private transactionsUsed = 0;
  private readonly monthlyLimit: number;

  constructor(tier: 'free' | 'paid' = 'free') {
    this.monthlyLimit = tier === 'free' ? 500 : Infinity;
  }

  recordTransaction(): void {
    this.transactionsUsed++;
    const remaining = this.monthlyLimit - this.transactionsUsed;

    if (remaining <= 50) {
      console.warn(`PDF Services: ${remaining} transactions remaining this month`);
    }
    if (remaining <= 0) {
      throw new Error('PDF Services monthly quota exceeded. Upgrade plan or wait for reset.');
    }
  }

  getUsage(): { used: number; limit: number; remaining: number } {
    return {
      used: this.transactionsUsed,
      limit: this.monthlyLimit,
      remaining: Math.max(0, this.monthlyLimit - this.transactionsUsed),
    };
  }
}

Scenario	Detection	Action
Single 429	`Retry-After` header	Wait specified seconds, retry
Sustained 429s	Multiple retries fail	Reduce concurrency; check tier
PDF `QUOTA_EXCEEDED`	Monthly limit hit	Upgrade tier or wait for reset
Events 429	3000/5sec exceeded	Reduce batch size or add queue