Skill UI

This skill provides comprehensive solutions for managing rate limits and throttling when interacting with the AssemblyAI Speech-to-Text API. It implements advanced patterns like exponential backoff with jitter, queue-based concurrency control, and resilient streaming retry logic. Use it when building high-throughput, reliable applications that process large volumes of audio data.

A comprehensive guide for handling API rate limits when interacting with the Attio platform. It covers advanced techniques including parsing the `Retry-After` header, implementing exponential backoff with jitter, and using queue-based throttling. The guide also introduces best practices like Circuit Breakers and batch operations to ensure reliable, high-performance, and resilient API integrations.

This module provides production-ready, type-safe patterns for interacting with the BambooHR REST API, supporting TypeScript and Python. It wraps raw HTTP calls into robust, retry-aware clients, handling complex tasks like error management and multi-tenancy. Use this when building reliable, enterprise-grade integrations with BambooHR.

This guide provides production-ready patterns for integrating with Bright Data proxy services. It covers critical aspects like setting up a proxy client, implementing robust retry logic for transient errors (e.g., 502, 503), managing sticky sessions for consistent IPs, and parsing complex HTML responses. Essential for building reliable, high-scale web scrapers using TypeScript and Python.

This guide provides production-ready code patterns for integrating with the Cohere AI API v2 using TypeScript and Python. It covers essential best practices, including singleton client management, robust retry mechanisms, type-safe chat wrappers, streaming, embedding, reranking, and structured JSON output. Use this when establishing team coding standards or refactoring existing Cohere integrations.

This skill provides comprehensive strategies for managing rate limits when interacting with the Figma REST API. It implements crucial patterns like exponential backoff, respects 'Retry-After' headers, utilizes request queuing with concurrency control, and includes a proactive rate limit monitor. Use this when developing high-volume, resilient integrations that frequently encounter 429 errors or require optimized API throughput.

This guide details the operational usage limits for Finta's core features, such as investor pipeline records, deal room creation, and AI suggestions. Since Finta lacks a traditional REST API, limits are defined by plan tiers. It provides reference tables and TypeScript examples for implementing usage tracking, robust webhooks retry strategies, and batch processing to ensure smooth scaling and prevent mid-raise disruptions during integrations.

This guide provides production-ready patterns for interacting with the Flexport REST API v2 in TypeScript and Python. It teaches crucial best practices, including implementing a singleton client for state management, handling paginated data streams, automatic retry logic, and using Zod for robust response validation, ensuring reliable logistics integrations.

This utility helps manage API rate limits when building parallel integrations with multiple financial providers (Gusto, QuickBooks, Plaid, Stripe). It implements a token bucket algorithm and robust retry strategies to prevent shared-limit conflicts and ensure reliable data synchronization during high-volume processes like month-end reconciliation.

This skill provides comprehensive guidelines and implementation examples for managing rate limits when interacting with the Glean Indexing and Search APIs. It includes a custom RateLimiter class, robust retry logic (handling 429 errors and server errors), and best practices for batch processing large datasets, ensuring stable, high-volume data ingestion pipelines.

A comprehensive guide and implementation pattern for handling rate limits, backoff, and idempotency when integrating with the Grammarly Text API. It provides a custom rate limiter and robust retry logic to manage API throughput, ensuring reliable processing of high volumes of documents and stable interaction with various endpoints (e.g., writing score, plagiarism checks).

This guide provides robust solutions for handling Hex API rate limits, implementing backoff, and ensuring idempotent API calls. It includes a rate limiter class and a retry mechanism with exponential backoff. Use this when building reliable data pipelines, running large-scale batch analytics, or integrating Hex into CI/CD environments where API call throttling is expected.