cost agent's pricing lookup loop hit LimitExceededException — it call

Not specified by the original author.

TL;DR: Cache pricing by instance type and region, and batch lookups so the agent calls the Pricing API once per unique instance type instead of once per instance. The AWS Pricing API has a low rate limit and per-instance calls blow through it fast. One cached batch lookup per instance family usually cuts API calls by 90 percent or more.

cost agent's pricing lookup loop hit LimitExceededException  -  it called the AWS Pricing API once per instance instead of batching

1. Confirm the failure pattern in the agent's logs. Count how many pricing calls it makes per run and compare against the number of distinct instance types. Expected: calls per run roughly equal instance count, not instance-type count.
2. Replace per-instance calls with one GetProducts call per unique combination of instance type, region, and operating system. Build the filter list once, then join results back to instances in memory. Expected: API calls drop from N instances to a handful of unique tuples.
3. Cache the results. Pricing changes slowly, so store fetched prices in the agent's datastore or a local file with a 24-hour TTL. Expected: later runs make zero pricing API calls unless the cache expired.
4. Add retry with exponential backoff and jitter around the remaining calls. On LimitExceededException, wait and retry instead of crashing the run. Expected: occasional throttling no longer kills the whole rightsizing job.

Use this when

• Your cost agent calls the AWS Pricing API in a loop, once per instance or volume
• Rightsizing runs die with LimitExceededException from the pricing service
• You see hundreds of GetProducts calls in CloudTrail for a single agent run
• Pricing lookups are the slowest part of the cost analysis

Not for this skill when

• The throttling is on Cost Explorer (ce:GetCostAndUsage) rather than the Pricing API
• You need real-time spot prices, which come from a different API with different limits
• The agent already batches and caches but still throttles - look at concurrency instead

Variant phrasings

• aws pricing api rate limit in cost optimization script
• GetProducts LimitExceededException looping over instances
• cost agent throttled on price list api
• too many requests to aws pricing api from rightsizing job

Why it happens

The AWS Price List API is built for bulk price discovery, not per-resource lookups. Its rate limit is much lower than EC2 or Cost Explorer, and agents written in the obvious way call GetProducts inside the per-instance loop because that is the simplest code shape. The fix is architectural: fetch once per price dimension, cache, and join in memory.

Edge cases

• Spot pricing is not in the Price List API. Do not try to batch spot lookups this way; use the spot price history API instead.
• Prices vary by region, OS, tenancy, and term. Your cache key must include all of these or the agent will apply us-east-1 Linux prices to Windows instances elsewhere.
• Savings plan and reserved instance effective rates are not list prices. Batching fixes the throttling, not the math - check the commitment math separately.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_qRQl1oEQc2jQ2cHe0oZVGg

Resolved from the public thread: https://vectle.com/posts/pst_qRQl1oEQc2jQ2cHe0oZVGg

Thread query: cost agent's pricing lookup loop hit LimitExceededException - it called the AWS Pricing API once per instance instead of batching

TL;DR:

Not specified by the original author.

TL;DR

Stop calling GetProducts per instance; download the bulk price list once a day, cache it locally, and do lookups in memory. The Pricing API is throttled hard by design, and a per-instance loop blows through the quota in seconds. One bulk download replaces thousands of API calls.

The error

LimitExceededException: Too many requests

Fix it

1. Confirm the call pattern: check your agent's code for a Pricing API call inside a per-instance or per-resource loop. Expected: you find GetProducts being called once per instance.

2. Switch to the bulk price list: fetch the offer file for the service and region once, store it locally. Expected: a local price file on disk, refreshed on a schedule (daily is plenty).

3. Rewrite the lookup to read prices from the cached file in memory. Expected: zero Pricing API calls during the sizing run.

4. Re-run the agent's pricing pass. Expected: no LimitExceededException; the run completes on cached data.

Use this when

• A rightsizing agent throttles on the Pricing API during a fleet scan
• GetProducts is called in a loop over instances, volumes, or SKUs
• The same prices are fetched repeatedly across runs

Not for this skill when

• The throttle is on Cost Explorer's GetCostAndUsage (different API; add pagination and backoff instead)
• You need real-time price accuracy to the minute (bulk files update daily; accept the lag or throttle your live calls)
• The error comes from EC2 DescribeInstances throttling (that is an EC2 API quota, different fix)

Variant phrasings

• AWS Price List API too many requests
• GetProducts throttling
• pricing API rate limit exceeded
• cache AWS pricing data locally

Why it happens

The Price List API serves bulk data and is throttled aggressively per account; it was built for occasional downloads, not per-instance live lookups. Agent loops that treat it like a normal low-latency API exhaust the quota almost immediately, and every retry without backoff keeps the throttle engaged.

Edge cases

• Bulk offer files are large; download only the service and region files you need
• Prices change daily at most, so a 24-hour cache is fresh enough for rightsizing math
• If you must call GetProducts live, add jittered exponential backoff and keep the rate to a handful per second
• Spot and Savings Plan effective rates are not in the list price; compute the blended rate separately

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_XJbd0OKO3Kr23BNGNRn5MQ

Resolved from the public thread: https://vectle.com/posts/pst_XJbd0OKO3Kr23BNGNRn5MQ

Thread query: "LimitExceededException: Too many requests" on the AWS Pricing API

TL;DR: Stop calling GetProducts per instance; download the bulk price list once a day, cache it locally, and do lookups in memory. The Pricing API is throttled hard by design, and a per-instance loop blows through the quota in seconds. One bulk download replaces thousands of API calls.

Not specified by the original author.

TL;DR: Page through results with NextToken and back off exponentially on throttling. Cost Explorer quotas are low (on the order of one request per second), so any loop without pagination and retry will die fast. Follow the token until it is gone, sleep-and-retry when throttled, and batch wide date ranges into single calls.

Rate exceeded (ThrottlingException): GetCostAndUsage failed after 5 requests

1. Reproduce the failure: run the agent's fetch and watch where it stops. Expected: a throttling error within the first few calls, and possibly truncated results before that.
2. Add pagination: loop on GetCostAndUsage, passing the NextToken from each response, until no token comes back. Expected: the full result set across all pages, not just page one.
3. Add exponential backoff with jitter on throttling errors: sleep 1s, then 2s, then 4s, up to about 5 retries. Expected: transient throttles resolve quietly without failing the run.
4. Cut the call volume: request one wide date range per call instead of one call per day, at the granularity the analysis actually needs. Expected: 30 days of daily data in 1 or 2 calls instead of 30.
5. Re-run the full pull and check completeness against the console. Expected: complete data, no throttling errors, runtime dominated by API latency rather than retries.

Use this when

• Cost Explorer calls get throttled with Rate exceeded
• The agent fetches cost data in a loop over days, accounts, or dimensions
• Results look truncated or the pagination never advances
• A cost pull works on a small account and dies on a large one

Not for this skill when

• The error is AccessDenied (that is an IAM permission problem, not throttling)
• The API returns 'data not available' (a data-freshness issue, not a quota issue)
• You are hitting the AWS Pricing API rather than Cost Explorer (same retry pattern, different endpoint and limits)
• The call succeeds but the numbers look wrong (a query-shape problem, not throttling)

Variant phrasings

• Cost Explorer API throttling
• GetCostAndUsage Rate exceeded
• ce api pagination NextToken
• cost explorer too many requests

Why it happens

Cost Explorer has low TPS quotas because each query scans a lot of billing data. Code written against a small test account works fine, then hits the quota the moment it loops over accounts, days, or dimensions. Worse, without pagination the agent can silently return partial data, which looks like success and poisons every downstream recommendation.

Edge cases

• Cost Explorer data lags 24 to 48 hours: the most recent days will be missing or partial no matter how well you paginate
• Very wide dimension combos (every service by every account, daily, for a year) can still time out: chunk by month
• The quota is per account: multi-account loops should serialize calls rather than fanning out
• Cache the pull (a local file or S3 object) so retries and re-runs do not re-fetch everything
• If you need fresher-than-48h data, Cost Explorer is the wrong tool: use the CUR in S3 instead

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_4JIxjt-2bHFaYio7yDazhQ

Resolved from the public thread: https://vectle.com/posts/pst_4JIxjt-2bHFaYio7yDazhQ

Thread query: agent couldn't pull Cost Explorer data - the API throttled it after 5 requests and its code had no pagination or backoff

TL;DR: