API 호출의 페이지 매김과 요청 속도 제한

APIs rarely return thousands of records in a single response. Instead they split results into pages. If your workflow only reads the first response, it silently misses most of the data.

Handling pagination ensures you retrieve everything.

Pagination is breaking a large result set into smaller chunks called pages. Each API call returns one page, plus a hint about how to get the next one.

Your workflow loops, requesting pages until there are no more.

One common style uses offset and limit. The limit says how many records per page; the offset says how many to skip.

To read page two with a limit of 50, you request offset 50. Page three uses offset 100, and so on.

Some APIs are even simpler: you pass a page number and a page size. Request page 1, then page 2, increasing until the response comes back empty.

An empty page signals you have reached the end.

Modern APIs often use a cursor: each response includes a token pointing to the next page. You pass that token in the following request.

Cursors are stable even when data changes between calls, making them more reliable than offsets.

In an automation, pagination usually means a loop: make a call, process the page, check for a next page or cursor, and repeat until done.

Some platforms have a built-in pagination setting; otherwise you build the loop manually with a repeater module.

A rate limit caps how many requests you may make in a time window — for example 60 calls per minute. Exceed it and the API rejects further calls, usually with a 429 Too Many Requests error.

Rate limits protect the API from overload.

Many APIs return headers telling you your status, such as how many requests remain and when the window resets.

Reading these lets your workflow slow down before it gets blocked rather than after.

The simplest way to stay under a limit is to add a short delay between calls. If you may make one call per second, a one-second pause in the loop keeps you safe.

Delays trade a little speed for reliability.

When you do hit a limit, the API returns 429, often with a Retry-After value telling you how long to wait. A robust workflow pauses for that duration, then retries.

This back-off behavior prevents a cascade of failed calls.

To fetch large datasets reliably:

• Always paginate; never assume one call returns everything
• Add delays to stay within rate limits
• Honor Retry-After and back off on 429
• Request only the fields and page sizes you need

Test your understanding of pagination and rate limits.

You learned to handle pagination and rate limits:

• Paginate to fetch full result sets using offset, page number, or cursor
• Loop through pages until there are no more
• Rate limits cap requests per time window; exceeding them returns 429
• Add delays, read limit headers, and honor Retry-After to back off

These practices keep your API automations complete and unblocked.