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".

仓库: jeremylongshore/claude-code-plugins-plus-skills
最近来源活动: 2026年7月17日 22:18
检测到的 SKILL.md 语言: 英语
星标: 2,604
分支: 378

安装方式

默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。

检查来源文件

决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。

返回搜索返回安装

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.6.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