Uniki User Guide

Appearance

8.2 Configuring Rate Limits ​

You understand why rate limits matter. Now let's configure them in your taibles. This section shows you exactly where to click, what to enter, and how to set up rate limiting for reliable, cost-controlled automation.

Where Rate Limits Are Configured ​

Column-Level Rate Limits ​

Rate limits are configured per column in the column edit sidebar.

Why column-level?

  • Each column may call different APIs
  • Each API has different limits
  • Fine-grained control
  • Independent configuration

Example:

Column A: Enrich with Clearbit

  • Rate limit: 10 per second

Column B: Send Email

  • Rate limit: 50 per hour

Column C: Update HubSpot

  • Rate limit: 100 per minute

Each column respects its own limit independently.

💡 💡 Independent Limits

Each column has its own separate rate limit. Setting a limit on one column doesn't affect others. This gives you precise control over each API or operation.

Step-by-Step: Enabling Rate Limiting ​

Step-by-Step Guide

Step 1 of 6
1

Open Column Configuration

Click the column header, then click the settings icon (⚙️) or three-dot menu (⋮) → "Edit Column"

⚙️

Visual: column-header

Detailed Instructions ​

Step 1: Open Column Configuration ​

From taible view:

  1. Locate the column you want to rate limit

    • Look at column headers across the top
    • Example: "Enrich with Clearbit"

  2. Click the column header

    • The column name at the top of the table

  3. Click the settings icon (gear icon ⚙️)

    • Usually in top-right of column header
    • OR: Click three-dot menu (⋮) → "Edit Column"

Result: Column edit sidebar opens on the right side of screen

Step 2: Navigate to Rate Limiting Settings ​

In column edit sidebar:

  1. Scroll down past these sections:

    • Column Name
    • Display Label
    • Node Type Configuration
    • Dependencies (if any)
    • Conditions (if any)

  2. Find "Run Configuration" section

    • Usually toward the bottom
    • Expandable section (click to expand if collapsed)
    • Contains execution settings

  3. Look for rate limiting option

    • Toggle switch labeled "Rate limit the calculation of rows"

Step 3: Enable Rate Limiting ​

In Run Configuration section:

  1. Find the toggle switch

    • Label: "Rate limit the calculation of rows"
    • OFF by default (gray)

  2. Click the toggle to turn ON

    • Switch slides to right
    • Changes from gray to cyan/teal
    • Additional fields appear below

Result: Rate limit configuration fields appear

💡 💡 Visual Feedback

When you enable the toggle, it smoothly animates from gray to cyan and additional configuration fields slide into view. This confirms rate limiting is now active.

Step 4: Configure Rate Limit Parameters ​

Run Configuration

Configure how and when this column executes

Control how many cells execute per time period

Three fields appear when rate limiting is enabled:

Field 1: Maximum Executions ​

What it is: How many executions are allowed?

Enter a number:

  • Example: 10 (for 10 executions)
  • Example: 100 (for 100 executions)
  • Example: 1000 (for 1000 executions)

Type: Positive whole number

Rules:

  • ✅ Must be greater than 0
  • ✅ Typically between 1 and 10,000
  • ❌ Cannot be negative
  • ❌ Cannot be zero
Field 2: Time Window ​

What it is: In what time period?

Enter a number:

  • Example: 1 (for "per 1 unit")
  • Example: 5 (for "per 5 units")
  • Example: 60 (for "per 60 units")

Type: Positive whole number

Rules:

  • ✅ Must be greater than 0
  • ❌ Cannot be negative
Field 3: Unit ​

What it is: What unit of time?

Dropdown menu with options:

  • Seconds - for very high-frequency operations
  • Minutes - most common for API calls
  • Hours - for email sending, batch operations
  • Days - for expensive operations, free tier APIs

Select one:

  • Click dropdown
  • Choose appropriate unit
  • Click to confirm

Understanding Your Configuration ​

Example 1: API Rate Limit

✓ Enable Rate Limiting: ON
Maximum Executions: 10
Time Window: 1
Unit: Seconds

Reads as: "10 executions per 1 second" = 10 per second

Example 2: Email Sending

✓ Enable Rate Limiting: ON
Maximum Executions: 50
Time Window: 1
Unit: Hours

Reads as: "50 executions per 1 hour" = 50 per hour

Example 3: Expensive API

✓ Enable Rate Limiting: ON
Maximum Executions: 100
Time Window: 1
Unit: Days

Reads as: "100 executions per 1 day" = 100 per day

💡 📖 Reading Rate Limits

The configuration always reads as: **[Count] executions per [Window] [Unit]**. For example, "50 per 1 hour" means the system will execute a maximum of 50 cells in any 1-hour period.

Step 5: Save Configuration ​

At the bottom of sidebar:

  1. Click "Save" button

    • Usually blue/cyan button
    • Bottom-right of sidebar

  2. Wait for confirmation

    • Success message appears
    • Sidebar may close

Result: Rate limiting is now active for this column! ✓

Common Rate Limit Configurations ​

Standard API

Most REST APIs

Count:10
Window:1
Unit:Seconds

10 API calls per second

Typical API rate limits, real-time integrations, high-volume processing

Email Sending

SMTP, transactional email

Count:50
Window:1
Unit:Hours

50 emails per hour

Gmail SMTP (500/day limit), avoid spam filters, gradual delivery

Free Tier API

Limited monthly quotas

Count:50
Window:1
Unit:Days

50 API calls per day

Monthly limit: 1,500 (50 × 30 days), spreads usage evenly, prevents quota exhaustion

Cost Control

Budget protection

Count:100
Window:1
Unit:Hours

100 API calls per hour

If API costs $1 per call: Max $100/hour, $2,400/day, $72,000/month

Configuration 1: Standard API (Per Second) ​

Use case: Most REST APIs

Settings:

  • Count: 10
  • Window: 1
  • Unit: Seconds

Means: 10 API calls per second

When to use:

  • Typical API rate limits
  • Real-time integrations
  • High-volume processing

Configuration 2: Email Sending (Per Hour) ​

Use case: SMTP, transactional email

Settings:

  • Count: 50
  • Window: 1
  • Unit: Hours

Means: 50 emails per hour

When to use:

  • Gmail SMTP (500/day limit)
  • Avoid spam filters
  • Gradual delivery

Configuration 3: Free Tier API (Per Day) ​

Use case: Limited monthly quotas

Settings:

  • Count: 50
  • Window: 1
  • Unit: Days

Means: 50 API calls per day

Why per day?

  • Monthly limit: 1,500 (50 × 30 days)
  • Spreads usage evenly
  • Prevents quota exhaustion
  • Sustainable usage

💡 💡 Free Tier Strategy

If you have a monthly quota (like 1,500 API calls per month), divide by 30 days to get your daily rate limit (50 per day). This ensures you never run out mid-month!

Configuration 4: Burst Allowance (Multiple per Second) ​

Use case: APIs that allow bursts

Settings:

  • Count: 100
  • Window: 10
  • Unit: Seconds

Means: 100 API calls per 10 seconds = 10 per second average

Benefit: Allows short bursts while respecting overall limit

Configuration 5: Cost Control (Per Hour) ​

Use case: Budget protection

Settings:

  • Count: 100
  • Window: 1
  • Unit: Hours

If API costs $1 per call:

  • Max: $100 per hour
  • Max: $2,400 per day
  • Max: $72,000 per month

Review regularly: Adjust limit based on results and budget

Advanced Configuration ​

Buffer Below Provider Limit ​

Best practice: Set your limit lower than the provider's limit

Why?

  • Account for timing variations
  • Prevent hitting the hard limit
  • Safety margin for errors
  • Handle retries gracefully

Example:

Provider limit: 100 requests per minute

Your configuration:

  • Count: 90
  • Window: 1
  • Unit: Minutes

Buffer: 10 requests (10% safety margin)

Result: You never hit the provider's hard limit ✓

💡 ⚠️ Safety Margins

Always set your rate limit slightly lower than the provider's limit (typically 10% lower). This prevents errors from timing differences and gives you room for retry attempts.

Multiple Time Windows ​

Some APIs have multiple limits:

Example: OpenAI GPT-4

  • Limit 1: 10,000 tokens per minute
  • Limit 2: 500 requests per minute

Your configuration (more restrictive):

  • Count: 60
  • Window: 1
  • Unit: Minutes

Why 60?

  • Average prompt: ~150 tokens
  • 60 requests × 150 tokens = 9,000 tokens
  • Stays under both limits ✓

Scaling Rate Limits Over Time ​

Testing strategy: Start conservative, increase gradually

Week 1: Testing

  • Count: 10
  • Window: 1
  • Unit: Hours

Actions:

  • Test with small volume
  • Verify correctness
  • Check costs

Week 2: Ramp Up

  • Count: 50
  • Window: 1
  • Unit: Hours

Actions:

  • Increase 5× if tests passed
  • Monitor closely

Week 3: Production

  • Count: 200
  • Window: 1
  • Unit: Hours

Actions:

  • Full production volume
  • Monitoring and alerts active

Safe rollout ✓

💡 ✅ Gradual Scaling

Start with a very low rate limit to test your automation. Once you confirm everything works correctly, gradually increase the limit over several days or weeks. This minimizes risk and cost.

Token-Based Rate Limiting (AI Columns) ​

Special Case: AI Columns ​

AI columns (like GPT-4, Claude) have token-based rate limiting.

What's different?

  • Not counting requests
  • Counting tokens (word pieces)
  • Variable per request

Configuring Token Limits ​

In AI column configuration:

  1. Open column edit sidebar (same as before)

  2. Navigate to "Run Configuration" section

  3. Enable Rate Limiting (toggle ON)

  4. Select rate limit type:

    • Dropdown: "Request-based" vs "Token-based"
    • Choose: Token-based

  5. Configure token limit:

    • Maximum Tokens: 10000
    • Time Window: 1
    • Unit: Minutes

  6. Save configuration

How Token Counting Works ​

The system automatically tracks tokens:

Before execution:

  1. Estimate tokens needed
  2. Check current usage
  3. If under limit → Execute
  4. If over limit → Wait (Rate Limited)

After execution:

  1. Count actual tokens used
  2. Add to current window
  3. Update usage tracking

Example:

Limit: 10,000 tokens per minute

Current usage: 8,500 tokens
Request 1: ~200 tokens → Allowed (total: 8,700)
Request 2: ~300 tokens → Allowed (total: 9,000)
Request 3: ~1,500 tokens → Rate Limited (would exceed 10,000)
    ↓
Wait until next minute
    ↓
Usage resets to 0
    ↓
Request 3: Allowed

Token Limit Presets ​

Common configurations:

GPT-4 (OpenAI):

  • Maximum Tokens: 10000
  • Window: 1
  • Unit: Minutes

(Matches OpenAI's TPM limit)

GPT-3.5 (OpenAI):

  • Maximum Tokens: 90000
  • Window: 1
  • Unit: Minutes

(Higher limit for cheaper model)

Claude (Anthropic):

  • Maximum Tokens: 100000
  • Window: 1
  • Unit: Minutes

(Higher default limits)

💡 📊 Tokens vs Requests

For AI columns, token-based limits are more accurate than request-based limits because token usage varies widely between requests. A short question uses few tokens, while a long conversation uses many.

Rate Limit Templates ​

Template 1: Conservative Testing ​

When: First time setting up automation

Configuration:

  • Count: 5
  • Window: 1
  • Unit: Minutes

Why:

  • Very slow (5 per minute)
  • Easy to monitor
  • Catch issues early
  • Minimal cost impact

Test: 5-10 rows, verify success, then increase

Template 2: Free Tier Protection ​

When: Using free APIs with monthly quotas

Configuration:

  • Count: 50
  • Window: 1
  • Unit: Days

Math:

  • 50 per day × 30 days = 1,500 per month
  • Adjust based on your quota

Example:

  • Clearbit free: 50 enrichments per month
  • Set to: 1 per day (30 per month)
  • Leaves buffer for manual tests

Template 3: Standard Production API ​

When: Typical REST API integration

Configuration:

  • Count: 90
  • Window: 1
  • Unit: Minutes

Assumes:

  • Provider limit: 100 per minute
  • Your limit: 90 (10% buffer)

Adjust based on provider documentation

Template 4: Email Delivery (Gmail SMTP) ​

When: Sending emails via Gmail

Configuration:

  • Count: 450
  • Window: 1
  • Unit: Days

Why:

  • Gmail limit: 500 per day
  • Your limit: 450 (10% buffer)
  • Leaves room for manual emails

Alternative (hourly):

  • Count: 18
  • Window: 1
  • Unit: Hours

(450 ÷ 24 hours ≈ 18 per hour)

Template 5: Cost Control ($100/day) ​

When: Expensive API ($1 per call)

Configuration:

  • Count: 100
  • Window: 1
  • Unit: Days

Math:

  • 100 calls per day
  • $1 per call
  • = $100 per day
  • = $3,000 per month

Adjust based on your budget

Template 6: High-Volume Processing ​

When: Large-scale operations with generous limits

Configuration:

  • Count: 1000
  • Window: 1
  • Unit: Hours

Means:

  • 1,000 per hour
  • ~16-17 per second
  • 24,000 per day

Use when:

  • Provider allows high volume
  • Costs are low
  • Infrastructure can handle it

💡 💡 Template Selection

Choose a template that matches your use case, then adjust the numbers based on your specific API provider's limits and your budget. Templates are starting points, not rigid rules!

Editing Existing Rate Limits ​

Change Rate Limit Settings ​

To adjust existing rate limit:

  1. Open column edit sidebar

    • Click column header
    • Click settings icon ⚙️

  2. Navigate to "Run Configuration" section

    • Scroll to Run Configuration
    • Find Rate Limiting subsection

  3. Modify values:

    • Count: Change number
    • Window: Change number
    • Unit: Change dropdown selection

  4. Save changes

    • Click "Save" button

Takes effect immediately: New rate limit applies to future executions

Currently executing cells: Complete under old limit

Queued cells: Use new limit

Disable Rate Limiting ​

To turn off rate limiting:

  1. Open column edit sidebar

  2. Navigate to "Run Configuration" section

  3. Toggle OFF

    • Click toggle switch
    • Changes from cyan to gray
    • Fields disappear

  4. Save changes

Result: Column executes without rate limiting (unlimited speed)

💡 ⚠️ Warning: Disabling Rate Limits

Only disable rate limiting if: - Testing locally - No external API calls - Provider has no limits - You know what you're doing

Without rate limits, your automation can quickly exhaust API quotas or generate unexpectedly high costs!

Testing Rate Limit Configuration ​

Method 1: Small Batch Test ​

Test new rate limit before full rollout:

  1. Configure rate limit (very conservative)

    • Count: 5
    • Window: 1
    • Unit: Minutes

  2. Create test rows:

    • Add 10 rows manually
    • Fill required dependencies
    • Wait for column to execute

  3. Observe behavior:

    • First 5 rows: Execute immediately (within 1 minute)
    • Next 5 rows: Rate Limited (wait for next minute)
    • After 1 minute: Next 5 execute

  4. Check timing:

    • Look at cell execution timestamps
    • Should see 1-minute gaps between batches

  5. Verify success:

    • All 10 cells: Done (green checkmark)
    • No failures
    • No errors

  6. Increase limit gradually:

    • Count: 50
    • Window: 1
    • Unit: Minutes

  7. Test again with larger batch (50-100 rows)

Method 2: Monitor Cell States ​

Column: Enrich with API

Rate Limit: 10 executions per 1 second

Row 1✓
Done
Row 2✓
Done
Row 3✓
Done
Row 4✓
Done
Row 5✓
Done
Row 6✓
Done
Row 7✓
Done
Row 8✓
Done
Row 9✓
Done
Row 10✓
Done
Row 11⏸
Rate Limited
Row 12⏸
Rate Limited
Row 13⏸
Rate Limited
Row 14⏸
Rate Limited
Row 15⏸
Rate Limited
Done (10 cells)
Rate Limited (5 cells waiting)

What's happening: The first 10 cells executed immediately (within 1 second). The remaining 5 cells are waiting because the rate limit of "10 per second" has been reached. They will execute in the next second.

Watch cells transition through states:

Visual monitoring:

  1. Add multiple rows that will trigger rate-limited column

  2. Watch cell states change:

    • Row 1-10: Idle → Queued → Running → Done
    • Row 11+: Idle → Queued → Rate Limited ⏸

  3. Confirm Rate Limited state:

    • Cell background: Yellow
    • Icon: Pause icon ⏸
    • Text: "Rate Limited" (italic)

  4. Wait for window to pass

  5. Watch cells proceed:

    • Row 11-20: Rate Limited → Running → Done

If cells proceed as expected: Rate limit is working ✓

💡 👁️ Visual Indicators

Rate-limited cells show a yellow background with a pause icon (⏸) and italic "Rate Limited" text. This makes it easy to see which cells are waiting for the rate limit window to reset.

Method 3: Check Timestamps ​

Verify timing mathematically:

  1. Execute rate-limited column on 20 rows

  2. After completion, check execution timestamps:

    • Click each cell
    • Look for execution time
    • Note the time

  3. Calculate gaps:

    Rate limit: 10 per second

Expected: 10 rows per second

Row 1: 12:00:00
Row 11: 12:00:01 (1 second later) ✓
Row 21: 12:00:02 (2 seconds later) ✓

  4. If gaps match rate limit: Working correctly ✓

Visual Indicators in UI ​

Column Header Indicators ​

When rate limiting is active:

Column header shows:

  • Tooltip: Information about rate limiting when hovering

When cells are rate limited:

  • Count indicator: Shows number of cells in various states
  • Example: Multiple cells waiting for rate limit

Cell Visual States ​

Rate Limited cells display:

Background color:

  • Yellow (waiting)

Icon:

  • Pause icon ⏸

Text:

  • "Rate Limited" in italic style

Color:

  • Yellow-600 (#ca8a04)

💡 🎨 Color Coding

The UI uses consistent colors: - **Green**: Done (completed successfully) - **Yellow**: Rate Limited (waiting for next time window) - **Amber**: Queued (waiting to execute) - **Red**: Failed (error occurred)

Best Practices for Configuring Rate Limits ​

Best Practice 1: Always Start Conservative ​

Don't guess high:

  • ❌ Bad: Set to 1,000/second (hoping it's okay)
  • ✅ Good: Set to 10/second (test, then increase)

Safer to start low:

  • Test with small volume
  • Verify no errors
  • Gradually increase

You can always increase: Can't undo expensive mistakes

Best Practice 2: Check Provider Documentation ​

Before setting rate limit:

  1. Find provider's API documentation
  2. Look for "Rate Limits" section
  3. Note the exact limits:
    • Requests per second/minute/hour
    • Tokens per minute (for AI)
    • Daily/monthly quotas
  4. Set yours lower (add buffer)

Example:

  • Provider: "100 requests per minute"
  • Your config: 90 per minute (10% buffer)

💡 ✅ Documentation First

Always check the API provider's documentation before configuring rate limits. Providers clearly state their limits, and respecting them prevents errors and potential account suspension.

Best Practice 3: Match Business Constraints ​

Consider downstream capacity:

Example: Order fulfillment

  • Warehouse: 20 orders per hour capacity
  • Your rate limit: 20 per hour
  • Match digital to physical ✓

Don't overwhelm downstream systems

Best Practice 4: Use Cost Calculators ​

For expensive APIs:

  1. Calculate cost per execution:

    • Example: $1 per enrichment

  2. Determine daily budget:

    • Example: $100 per day

  3. Set rate limit to match:

    • Cost per call: $1
    • Daily budget: $100
    • Rate limit: 100 per day

  4. Monitor actual spend vs. limit

Best Practice 5: Consider Time Zones ​

For time-sensitive operations:

Example: Email campaigns

Bad configuration:

  • Count: 1000
  • Window: 1
  • Unit: Days

(All 1,000 might send at midnight)

Better configuration:

  • Count: 40
  • Window: 1
  • Unit: Hours

(Spreads throughout day: 40 × 24 = 960 per day)

Plus: Add conditional execution for business hours

Best Practice 6: Plan for Retries ​

Assume some requests will fail:

Your rate limit should account for retries:

Example:

  • Provider limit: 100 per minute
  • Expected failure rate: 5%
  • Expected retries: 5 per minute
  • Your limit: 90 per minute (leaves room for 10 retries)

Buffer protects against retry spikes

💡 💡 Retry Buffer

Not every API call succeeds on the first try. Build in a buffer to your rate limit to allow for automatic retries without hitting the provider's limit.

Troubleshooting Rate Limit Configuration ​

Problem 1: Cells Stay Rate Limited Forever ​

Symptom: Cells never leave Rate Limited state

Possible causes:

1. Rate limit too restrictive

  • Example: 1 per day with 1,000 rows queued
  • Will take 1,000 days to complete!

Solution: Increase rate limit

  • Change from: 1 per day
  • Change to: 100 per hour

2. Time unit mismatch

  • You thought you set "per second" but set "per day"

Solution: Check configuration

  • Open column config
  • Verify Unit dropdown
  • Correct if wrong

3. Rate limit conflict

  • Multiple rate limits applying
  • Organization-level limit hit

Solution: Check organization settings

  • Organization dashboard
  • Look for global limits
  • Contact admin if needed

Problem 2: All Cells Fail (Not Rate Limited) ​

Symptom: Cells go Running → Failed (not Rate Limited)

Diagnosis: Rate limit is too aggressive for provider

What happens:

Your limit: 100 per second
Provider limit: 10 per second
    ↓
Your system sends: 100 per second
Provider rejects: 90 requests (error)
    ↓
90 cells: Failed

Solution: Lower your rate limit

  • Change from: 100 per second
  • Change to: 9 per second (under provider limit)

💡 ⚠️ Failed vs Rate Limited

If cells are **failing** instead of being **rate limited**, your rate limit is set higher than the API provider allows. Lower your rate limit to match the provider's restrictions.

Problem 3: Rate Limit Not Working ​

Symptom: All cells execute immediately (no throttling)

Possible causes:

1. Rate limiting not enabled

Solution: Check configuration

  • Open column config
  • Rate Limiting section
  • Toggle is ON? (cyan)
  • If OFF: Turn ON and save

2. Rate limit too high

  • Example: 10,000 per second
  • If you only have 100 rows, all execute immediately

Solution: Verify row count

  • Is your row count under the rate limit?
  • If yes: This is normal (limit not reached)

3. Caching or dependencies

  • Column not actually executing
  • Using cached results

Solution: Check run mode

  • Run mode: Is it set to only run once?
  • Clear cache and retry

Problem 4: Costs Higher Than Expected ​

Symptom: Bill is higher than rate limit math suggests

Example:

Rate limit: 100 per day
Cost per call: $1
Expected: $100 per day
Actual: $500 per day (?!)

Possible causes:

1. Multiple columns calling APIs

  • Column A: 100 calls per day ($100)
  • Column B: 200 calls per day ($200)
  • Column C: 200 calls per day ($200)
  • Total: $500 per day

Solution: Check all columns, not just one

2. Retries not counted in rate limit

  • Failed requests retry
  • Retries consume API quota
  • But may not respect rate limit

Solution: Monitor actual API usage vs. configuration

3. Sub-taibles

  • Parent taible: 10 rows
  • Each has 100 child rows
  • Child column runs: 10 × 100 = 1,000 times
  • Rate limit on parent doesn't apply to child

Solution: Set rate limits on child taible columns too

💡 ⚠️ Sub-Taible Multiplication

Rate limits on parent taible columns don't apply to child taible columns! If you have sub-taibles, make sure to set appropriate rate limits on child columns as well.

Summary: Configuring Rate Limits ​

You now know how to:

✅ Find rate limit settings: Column edit sidebar → Run Configuration → Rate Limiting toggle

✅ Enable rate limiting: Toggle ON, configure three parameters

✅ Configure parameters:

  • Count (how many executions)
  • Window (time period length)
  • Unit (seconds/minutes/hours/days)

✅ Use common templates:

  • Testing: 5 per minute
  • Free tier: 50 per day
  • Standard API: 90 per minute
  • Email: 450 per day
  • Cost control: Based on budget

✅ Advanced configurations:

  • Buffer below provider limit (10% safety margin)
  • Token-based limits for AI columns
  • Scaling over time (start low, increase gradually)

✅ Test configurations:

  • Small batch test (10 rows)
  • Monitor cell states (yellow = rate limited)
  • Check timestamps (verify timing)

✅ Visual indicators:

  • Cell state: Yellow background with pause icon
  • Text: "Rate Limited" in italic
  • Color: Yellow-600

✅ Best practices:

  • Start conservative (test first)
  • Check provider documentation (know the limits)
  • Match business constraints (don't overwhelm systems)
  • Use cost calculators (budget protection)
  • Plan for retries (add buffer)

✅ Troubleshoot issues:

  • Cells stuck: Increase rate limit or check unit
  • Failures: Lower rate limit to match provider
  • Not working: Verify toggle is ON
  • High costs: Check all columns and sub-taibles

Next Steps ​

Now that you know how to configure rate limits, Section 8.3 will show you:

  • How to monitor rate limit usage
  • Dashboard indicators
  • Real-time statistics
  • Understanding rate limit metrics
  • Optimizing for performance and cost

Let's learn to monitor your rate limits! 📊

Built with VitePress

Copyright © 2025 Uniki