Kiro Pricing in 2026: Plans, Credits, Model Multipliers and Worked Monthly Bills

By TwitterAPI.io Team•17 min read
Diagram of how Kiro credits are spent. A prompt, spec task or agent hook run (for example 10 credits on Auto) is multiplied by the model multiplier (Qwen3 Coder Next 0.05x, Haiku 4.5 0.4x, Auto 1.0x, Sonnet 1.3x, Opus 5.5 2.0x, GPT-5.6 Sol 4.4x), then drawn first from plan credits (Pro 1,000 for $20, Pro+ 2,000 for $40, Pro Max 5,000 for $100, Power 10,000 for $200), then 500 trial credits, then add-on credits at $0.04 each. With nothing left, requests pause. Moving up a tier is cheaper than add-ons above 1,500, 3,500 and 7,500 credits a month.
How a month of Kiro credits is metered and spent, from Kiro's pricing and models pages.
TL;DR
  • Plans (per user, per month): Free $0 / 50 credits, Pro $20 / 1,000, Pro+ $40 / 2,000, Pro Max $100 / 5,000, Power $200 / 10,000. Every paid tier works out to $0.02 per included credit.
  • Running out: plan credits first, then trial credits, then add-on credits at $0.04 each (packs from $5 for 125, valid 12 months). With nothing left, requests pause until the monthly reset.
  • Model multipliers decide the bill: Auto 1.0x, Sonnet 4.6 1.3x, Opus 5.5 2.0x, Opus 5 2.2x, GPT-5.6 Sol 4.4x; Haiku 4.5 0.4x and Qwen3 Coder Next 0.05x stretch the same plan much further.
  • When to move up a tier: on list prices, upgrading beats add-ons above 1,500 credits a month (Pro to Pro+), 3,500 (to Pro Max) and 7,500 (to Power).
  • What X says: of 383 posts about Kiro pricing (collected in 2026), 39.7% are about free credits, trials or student and hackathon offers, and only 2.3% call Kiro expensive.
  • X data in Kiro: our MCP server plugs into .kiro/settings/mcp.json; X reads cost $0.15 per 1,000 tweets returned vs $5.00 at the official X API's $0.005 per post read.

Kiro, the agentic IDE that AWS builds and operates, sells usage in credits rather than seats with unlimited prompts. The headline prices are easy to find; what most pricing write-ups skip is how fast a month of credits actually goes, which depends on the model multiplier, the order in which Kiro spends plan, trial and add-on credits, and the point at which buying add-ons costs more than the next tier. This page works through those mechanics from Kiro's own pricing page, models page and billing docs, read this session, and turns them into monthly bills for six usage profiles.

We also pulled 383 recent X posts about Kiro's pricing and the latest 160 posts from @kirodotdev to see what people actually discuss when they talk about Kiro's price, and we show how to wire X (Twitter) data into Kiro through MCP with the read bill priced out.

If you are choosing between editors, our head-to-heads cover that: Kiro vs Cursor and Kiro vs Claude Code compare workflows, models and plans side by side. This page stays on Kiro's own pricing mechanics and does not repeat those comparisons.

Share of X posts about Kiro pricing that are about free credits, trials or student and hackathon offers

39.7% of 383 recent X posts (collected in 2026); only 2.3% call Kiro expensive and 4.7% mention add-on credits or overage.

01 — Section

Kiro plans and prices at a glance

Prices below are copied from kiro.dev/pricing as shown this session: US dollars, per user, per month, taxes excluded. Kiro charges all paid subscriptions on the 1st of each calendar month.

PlanPrice a monthCredits a monthPer included creditAdd-on credits
Kiro Free$050n/aNot available
Kiro Pro$201,000$0.02$0.04 each
Kiro Pro+$402,000$0.02$0.04 each
Kiro Pro Max$1005,000$0.02$0.04 each
Kiro Power$20010,000$0.02$0.04 each
Teams (pooled)$20 per seat500 per seat, shared$0.04$0.04 each, bought by admins

The flat $0.02 is the key number. Kiro does not discount credits on bigger plans: each paid tier buys included credits at exactly $0.02, and add-on credits cost double that. The higher tiers are not cheaper per credit; they are a way to buy more credits at the $0.02 rate instead of paying $0.04 for the overflow. That is why the right tier is simply the one whose allowance covers a typical month.

Model access. Free gets open-weight models and Claude Sonnet 4.5 with limits. Paid tiers get the premium models: the default Auto agent, OpenAI GPT-5.6 (Sol, Terra and Luna), Anthropic Claude Opus 5, Opus 4.8, Sonnet 5, Sonnet 4.6, Sonnet 4.5 and Haiku 4.5, and open-weight models such as DeepSeek 3.2, MiniMax M2.5, GLM-5 and Qwen3 Coder Next. Availability varies by country or region.

One subscription, every surface. Kiro's pricing page says plans work with the Kiro IDE, the CLI, Kiro Web, Kiro Crew, ACP-compatible IDEs and CI/CD automation. The old CLI billing page now redirects to the shared billing docs, so there is no separate Kiro CLI price. Kiro Web uses the same credits with no separate compute charge and needs Pro or above, and Kiro powers carry no additional charge. Headless CLI runs (kiro-cli chat --no-interactive with a KIRO_API_KEY) are also limited to Pro, Pro+, Pro Max and Power. One restriction: third-party harnesses that route requests outside Kiro's own interfaces are not permitted on a subscription.

Pro Max is the newest tier. Kiro added it on June 11, 2026 to fill the gap between Pro+ and Power, and its announcement makes the case for flat tiers over pay-as-you-go: overages "can be unpredictable and become expensive", while Pro Max offers "a predictable flat rate".

02 — Section

What a Kiro credit is, and what draws credits

Kiro defines a credit as a unit of work in response to a prompt. A simple prompt can cost less than one credit; a complex task such as executing a spec task usually costs more. Usage is metered to two decimal places, so the smallest charge is 0.01 credits, and the dashboard updates at least every five minutes.

What spends credits. Prompts in vibe mode or spec mode, spec refinement, spec task execution and agent hook executions all draw credits, and workflows use credits according to the agent work they run. Kiro's billing FAQ adds that an action needing a large amount of context or output can count as more than one credit, and that you pay per request, not per token: Kiro reuses context and uses provider-level prompt caching to cut token spend on its side.

What does not. Kiro powers have no extra charge, and Kiro Web adds no compute fee on top of credits. Anything outside Kiro, such as the APIs your code or an MCP server calls, is billed by that provider, not in Kiro credits.

Vibe and spec share one pool. Kiro once had separate limits for vibe and spec requests. Its September 15, 2025 pricing post replaced them with a single credit pool, fractional metering and Auto as the default agent, so a spec task is now just a larger draw on the same credits rather than a scarcer kind of request.

Why spec work costs more. A spec runs several agent steps: drafting requirements.md, design.md and tasks.md, then executing each task. Every step is agent work. A hook that runs the agent on every file save is a quiet credit consumer too; if your bill grows faster than your prompting, check the hooks first. For how specs, steering and hooks work as features, see our Kiro vs Cursor and Kiro vs Claude Code pages.

03 — Section

Model multipliers: the part of Kiro pricing that moves the bill

Every model on Kiro's models page carries a credit multiplier relative to Auto (1.0x). Kiro's own example: a task that costs 10 credits on Auto costs 20 on Claude Opus 5.5 and 0.5 on Qwen3 Coder Next. The table uses that 10-credit task to show how far 1,000 Pro credits go on each model.

ModelMultiplierCredits for a 10-credit Auto taskSuch tasks per 1,000 credits
Qwen3 Coder Next0.05x0.52,000
Claude Haiku 4.50.4x4250
GPT-5.6 Luna0.6x6166
Auto (default)1.0x10100
Claude Sonnet 4.6 or Sonnet 51.3x1376
Claude Opus 5.52.0x2050
Claude Opus 5 or Opus 4.82.2x2245
GPT-5.6 Sol4.4x4422

Long context costs more on some models. GPT-5.6 Sol, Terra and Luna double their multiplier above 272K tokens (Sol goes to 8.8x), and Claude Haiku 5.5 is 0.06x up to 100K tokens and 0.3x above. Claude Fable 5.1 is listed at 6x for Enterprise only, with model governance enabled.

The same multiplier is not the same bill. Kiro warns that models sharing a multiplier will not necessarily use the same credits for a task: tokens generated, thinking depth, tokenizer and reasoning effort all change the count. Treat the table as a ratio, and measure your own average task cost in the usage dashboard for a week before picking a tier.

The bigger lever is the model, not the plan. Moving routine edits from Opus 5 (2.2x) to Haiku 4.5 (0.4x) cuts their credit cost by more than 80% on any plan. One practical setup: keep Auto as the default and switch to Opus only for design-heavy spec work.

04 — Section

When credits run out: add-ons, overage and upgrading

Kiro spends credits in a fixed order: plan credits first, then any trial credits, then add-on credits. Its billing FAQ says requests pause only when no credits remain, until the plan credits reset at the start of the next month or you buy add-ons. The Free tier has fixed limits and cannot buy add-ons.

Add-on credits. On the individual paid plans (social login or AWS Builder ID), add-ons cost $0.04 per credit, are billed immediately, come in packs from $5 (125 credits) up to $100, appear as separate line items, and roll over until 12 months after purchase. Plan credits, by contrast, do not roll over: whatever is left at the end of the month is gone.

What happened to overage. When Kiro introduced credit plans on September 15, 2025, extra usage was an overage setting: off by default, enabled in Settings, billed at $0.04 per additional credit. The current pricing page sells prepaid add-on packs at the same $0.04 instead, says team credit pooling does not use overages, and notes that existing Enterprise customers on Pro, Pro+, Pro Max or Power can keep using overages. For an individual buyer today, "Kiro overage" means add-on credits.

Upgrade or buy add-ons? Upgrades take effect immediately and are prorated to the second; downgrades take effect the following month, and the current month is charged in full. Comparing a plan plus add-ons with the next tier on list prices gives three switch points:

Monthly credits neededLower billWhy
Up to 1,500Pro plus add-ons$20 + 500 add-ons x $0.04 = $40, the Pro+ price
1,500 to 3,500Pro+ plus add-ons$40 + 1,500 x $0.04 = $100, the Pro Max price
3,500 to 7,500Pro Max plus add-ons$100 + 2,500 x $0.04 = $200, the Power price
Above 7,500Power, plus add-ons past 10,000No higher individual tier

Month-end rule of thumb. Kiro's own advice matches the arithmetic: with only a few days left in the month, add-ons are usually simplest, unless your add-on spend is approaching the price difference to the next tier. Since add-ons keep for 12 months and plan credits do not, a small add-on pack is also the safer buffer for an uneven month.

Line chart of Kiro's monthly bill against credits needed, from 0 to 14,000 credits, for Pro ($20, 1,000 credits), Pro+ ($40, 2,000), Pro Max ($100, 5,000) and Power ($200, 10,000), each plus add-on credits at $0.04. The lowest bill switches from Pro to Pro+ at 1,500 credits, to Pro Max at 3,500 and to Power at 7,500. Side panel lists six worked profiles from 400 credits on Pro for $20 to 8,800 credits on Power for $200.
Monthly Kiro bill by credits needed, on list prices from kiro.dev/pricing. The dashed line is the lowest bill; dots mark where the next tier becomes cheaper.
05 — Section

Worked monthly bills for six usage profiles

To turn credits into dollars, we priced six profiles. Each assumes Kiro's illustrative 10-credit Auto task, a monthly task count and a main model, then picks the lowest bill on list prices. Your real task cost will differ; replace the 10 with your own dashboard average in the script below.

Profile (tasks a month, model)CreditsLowest billPro plus add-ons
Weekend builder (40, Auto)400Pro $20$20
Daily solo developer (100, Claude Sonnet 4.6)1,300Pro $32$32
Daily developer on Opus (150, Claude Opus 5.5)3,000Pro+ $80$100
Heavy agent user (200, Claude Opus 5)4,400Pro Max $100$156
Same heavy user on Haiku (200, Claude Haiku 4.5)800Pro $20$20
GPT-5.6 Sol power user (200, GPT-5.6 Sol)8,800Power $200$332

Reading the bills. A daily developer on Sonnet 4.6 needs about 1,300 credits, so Pro plus a $12 add-on beats Pro+ ($32 vs $40). Add-ons are sold in packs (from $5 for 125 credits), so a real purchase rounds up slightly. Move the same developer to Opus 5.5 at 150 tasks and the need jumps to 3,000 credits: Pro+ plus add-ons at $80 is the lower bill, and staying on Pro would cost $100. A heavy Opus 5 user at 4,400 credits lands on Pro Max for $100.

The model swing is bigger than the tier swing. The heavy user's 200 tasks cost 4,400 credits on Opus 5 but 800 on Haiku 4.5: $100 against $20 a month. On GPT-5.6 Sol the same 200 tasks need 8,800 credits and the Power plan.

Free tier reality check. 50 credits a month is five 10-credit Auto tasks, enough to try specs and hooks, not to build with. The first-upgrade trial (below) is the cheaper way to test a real month.

python
# kiro_bill.py - pick the lowest Kiro bill for a month of work (list prices from kiro.dev/pricing)
PLANS = [("Pro", 20, 1000), ("Pro+", 40, 2000), ("Pro Max", 100, 5000), ("Power", 200, 10000)]
ADDON = 0.04  # US dollars per add-on credit, paid plans only

# credit multipliers relative to Auto, from kiro.dev/docs/models
MULT = {"Auto": 1.0, "Claude Sonnet 4.6": 1.3, "Claude Opus 5.5": 2.0, "Claude Opus 5": 2.2,
        "Claude Haiku 4.5": 0.4, "GPT-5.6 Sol": 4.4, "GPT-5.6 Luna": 0.6, "Qwen3 Coder Next": 0.05}


def monthly_bill(credits_needed):
    options = []
    for name, fee, included in PLANS:
        extra = max(0, credits_needed - included)
        options.append((round(fee + extra * ADDON, 2), name, extra))
    return min(options)


def credits_for(tasks, auto_credits_per_task, model):
    return tasks * auto_credits_per_task * MULT[model]


if __name__ == "__main__":
    # replace 10 with your own average from the Kiro usage dashboard
    for tasks, model in [(100, "Claude Sonnet 4.6"), (150, "Claude Opus 5.5"), (200, "Claude Haiku 4.5")]:
        need = credits_for(tasks, 10, model)
        cost, plan, extra = monthly_bill(need)
        print(f"{tasks} tasks on {model}: {need:,.0f} credits -> {plan}"
              f" + {extra:,.0f} add-on credits = ${cost:,.2f}/month")
06 — Section

Free tier, trials, students, teams and Enterprise

Free. Kiro Free is a perpetual $0 tier with 50 credits a month, open-weight models and Claude Sonnet 4.5 with limits. It is not offered on Enterprise or AWS GovCloud.

First-upgrade trial. Under the rules Kiro's billing docs date from November 1, 2026, your first upgrade from Free to Pro makes the rest of that month free and adds 500 trial credits usable within 12 months. A valid card is required, plan fees and credits are prorated to the second, and the first bill arrives on the 1st of the following month. Starting on Pro+, Pro Max or Power still counts as the free Pro month: you pay only the prorated difference. Trial credits are spent after plan credits, and if you return to Free, unused trial credits stay but only work on free-tier models. Because the free part is the rest of the month, upgrading early in a month gets more free days.

Students. Kiro's student program, expanded on September 8, 2026 to 121 more universities in 16 countries, gives verified students one year of Kiro with 1,000 credits a month, no credit card and no overages, verified once through SheerID with a university email. Unused credits do not carry over, and after the year the account moves to the Free plan.

Teams and Enterprise. Credit pooling costs $20 per seat per month for two or more seats; each seat adds 500 credits a month to a shared pool, and admins can buy more at $0.04 each. Included pool credits expire at the end of each month; admin-bought add-ons last 12 months. Admins get alerts at 80% and 100% of the pool and can cap usage per user, group or profile. Note that a pooled seat brings 500 credits, half of an individual Pro plan's 1,000, for the same $20.

Taxes, regions and GovCloud. Prices exclude applicable taxes; Japanese billing addresses pay Japanese Consumption Tax. Paid plans need a billing address in a supported country or region, and Enterprise is billed through AWS. Kiro in AWS GovCloud (US) is priced about 20% above commercial pricing.

07 — Section

What people on X say about Kiro pricing

We searched X for posts that pair Kiro with pricing words (credits, pricing, price, overage, Pro+, Pro Max, subscription, plan) and kept 383 posts from 280 accounts after removing reposts, the official account and unrelated uses of the name. They span about 360 days, roughly 1.06 a day.

Free credits dominate the conversation. 39.7% of the posts are about free credits, the first-upgrade trial, the student program or hackathon credit grants: more than name any single plan. Posts about running out of or burning credits are 5.2%, and add-on credits or overage come up in only 4.7%.

What the post mentionsPostsShareMedian likes
Free credits, trials, student or hackathon offers15239.7%3
A specific model or Auto13535.2%5
Names a Kiro plan (any tier)13234.5%n/a
Pro (the $20 tier)6517.0%3
Pro+379.7%4
Pro Max / Power22 / 225.7% / 5.7%3 / 2.5
Calls it cheap, good value or worth it307.8%4
Calls it expensive92.3%5

$20 is the price people quote. "$20" appears in 68 posts, against 21 for "$100", 10 for "$200" and 9 for "$40". By keyword, value judgments lean positive: 30 posts call Kiro cheap, good value or worth it, 9 call it expensive.

Kiro pricing is discussed next to other agents. 28.2% of the posts name another coding tool: Claude Code 18.3%, Codex 18.0%, Cursor 16.2%, GitHub Copilot 8.1%. Model names come up in 35.2%, which fits a pricing model where the model choice sets the burn rate.

Not only English. English is 61.1% of the posts, Chinese 23.8% and Japanese 11.5%. Median likes are 3 (p90 83) and median views 449 (p90 13,164).

The official account talks pricing too. Of 98 original posts in the latest 160 from @kirodotdev (22,707 followers), 29 (29.6%) are about pricing, credits, plans, trials or the free tier. Those posts earned a median 116 likes and 9,946 views, against 51 likes and 6,160 views for its other original posts.

Horizontal bar chart of what 383 X posts about Kiro pricing mention: free credits, trials, student or hackathon offers 39.7%, a specific model or Auto 35.2%, a Kiro plan 34.5%, Claude Code 18.3%, Codex 18.0%, Cursor 16.2%, cheap or worth it 7.8%, teams or credit pooling 5.7%, running out of credits 5.2%, add-ons or overage 4.7%, expensive 2.3%.
Share of 383 X posts about Kiro pricing that mention each topic; keyword-matched, a post can count in several rows. Collected in 2026.
08 — Section

Adding X (Twitter) data to Kiro, and what it costs

Kiro is an MCP client, so live X data comes in through a remote MCP server. Save the block below as .kiro/settings/mcp.json in the workspace or ~/.kiro/settings/mcp.json for every project; if both exist they are merged and the workspace wins. The TwitterAPI.io hosted server is https://mcp.twitterapi.io/mcp with your API key sent as a Bearer token. Kiro expands ${VARIABLE_NAME} in headers only for environment variables you approve (search "Mcp Approved Env Vars" in Kiro settings), which keeps the key out of the file.

Two separate bills. The agent work Kiro does to decide on and read a tool call is billed in Kiro credits like any other prompt. The X data itself is billed by TwitterAPI.io: 15 credits per tweet returned, which is $0.15 per 1,000 tweets, and 18 credits per profile ($0.18 per 1,000). A request that returns nothing still costs the 15-credit minimum ($0.00015), and a full 20-tweet page costs $0.003. $1 buys 100,000 credits, and purchased credits never expire.

JobTwitterAPI.ioOfficial X API (pay-per-usage)
Read 1,000 tweets$0.15$5.00 ($0.005 per post read)
Read 1,000 profiles$0.18$10.00 ($0.010 per user read)
This page's whole study (958 tweets, 1 profile)about $0.144about $4.80 at the same rate card

Named rate card. The official prices come from the X API pay-per-usage card at docs.x.com/x-api/getting-started/pricing: $0.005 per post read and $0.010 per user read, capped at 3 million post reads a month before Enterprise. Per 1,000 tweets that is $5.00 against $0.15, about 33x. New TwitterAPI.io accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). Reads need no X account.

A spec that uses it. Put the data source in the requirements ("fetch posts with the twitterapi-io MCP search tool") so Kiro's design and tasks are built around real fields such as likeCount, viewCount and author.followers, and a steering file can hold the field list. The Python script in this page's code block is the plain REST version of the same idea: it watches X for Kiro pricing news, so you hear about the next plan change from @kirodotdev the day it lands. For a full Kiro project built on X data, see our guide to building Twitter apps with the Kiro AI IDE.

Posting from an agent. Writes are available too: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each post, like, follow or retweet through /twitter/create_tweet_v2 and its siblings is 60 credits ($0.0006), billed per HTTP 200 call. The call acts as that account, so X can rate-limit, lock or suspend it; keep a human pace, and expect the session to need a re-login from time to time.

json
{
  "mcpServers": {
    "twitterapi-io": {
      "url": "https://mcp.twitterapi.io/mcp",
      "headers": { "Authorization": "Bearer ${TWITTERAPI_IO_API_KEY}" }
    }
  }
}
09 — Section

How we collected this

Question. When people on X talk about Kiro's pricing, what do they talk about: which plans, which models, running out of credits, add-ons, free offers, value judgments, and which other tools? And how much of the official @kirodotdev feed is about pricing?

Query and accounts. Search: (kiro OR kirodotdev) (credits OR credit OR pricing OR price OR overage OR "pro+" OR "pro max" OR subscription OR plan OR "per month") -filter:retweets, up to 40 pages of Latest and 8 pages of Top results, deduplicated. We kept posts that contain the word Kiro, a pricing term and a coding-tool context word, and dropped the official account, reposts and unrelated uses of the name (for example, a Seattle broadcaster). Official account: @kirodotdev profile plus its latest 160 posts, replies included.

Window and sample. The most recent matching posts at collection time, collected in 2026. The search returned 798 tweets (721 unique) and 383 were kept from 280 accounts; the official timeline gave 98 original posts. 51 requests in total, 958 tweets and 1 profile returned, about $0.144 at our rates.

Method. Topics were matched with case-insensitive regular expressions on post text in English, Chinese, Japanese and Korean. Plan names were matched conservatively ("Pro" only next to Kiro, $20 or 1,000 credits). The bill model uses list prices from kiro.dev/pricing and multipliers from kiro.dev/docs/models; it is arithmetic on published prices, not X data. Scripts and results are in our repository under data/studies/kiro-pricing/.

What the sample cannot show. Keyword matching misses sarcasm and posts that describe a price without the exact words, and round-up posts that list many deals count once each. X search returns a sample, not every post. Posts are not a measure of how many people pay for Kiro or what they spend; satisfied users rarely post about their bill. Some posts describe offers whose terms we could not verify, so this page states only the terms on Kiro's own pages.

Privacy. Aggregates only. Search authors are private individuals: their raw posts were not stored in the repository, and the de-identified sample keeps only language, counts, topic flags and a follower bucket (no ids, URLs, text or handles). Only the organization account @kirodotdev is named.

python
"""kiro_pricing_watch.py - follow Kiro pricing news on X (Twitter).

Checks @kirodotdev and public posts for pricing, credit and plan news and prints new ones.
pip install requests
export TWITTERAPI_IO_API_KEY=...   # from the twitterapi.io dashboard
"""
import os
import time

import requests

API_KEY = os.environ["TWITTERAPI_IO_API_KEY"]
BASE = "https://api.twitterapi.io"
QUERIES = [
    "from:kirodotdev (credits OR pricing OR plan OR trial OR overage)",
    "kiro (credits OR pricing OR \"pro+\" OR \"pro max\") min_faves:20 -filter:retweets",
]
INTERVAL = 900      # seconds between checks; an empty check is billed the 15-credit minimum
MAX_PAGES = 3       # safety cap per query per check; a full page holds up to 20 tweets


def search_page(query, cursor=None):
    params = {"query": query, "queryType": "Latest"}
    if cursor:
        params["cursor"] = cursor
    r = requests.get(
        f"{BASE}/twitter/tweet/advanced_search",
        headers={"X-API-Key": API_KEY},
        params=params,
        timeout=30,
    )
    if r.status_code != 200:
        raise RuntimeError(f"HTTP {r.status_code}: {r.text[:300]}")
    return r.json()


def new_posts(query, since_unix, seen):
    found, cursor = [], None
    for _ in range(MAX_PAGES):
        page = search_page(f"{query} since_time:{since_unix}", cursor)
        for tw in page.get("tweets", []):
            if tw["id"] not in seen:
                seen.add(tw["id"])
                found.append(tw)
        if not page.get("has_next_page"):
            break
        cursor = page.get("next_cursor")
    return found


def main():
    seen = set()
    since = int(time.time()) - 7 * 86400     # first run: the last 7 days
    while True:
        started = int(time.time())
        for query in QUERIES:
            for tw in reversed(new_posts(query, since, seen)):
                author = tw.get("author") or {}
                print(f"{tw['createdAt']}  @{author.get('userName')}  "
                      f"likes={tw.get('likeCount', 0)} views={tw.get('viewCount', 0)}")
                print("   ", tw["text"].replace("\n", " ")[:220])
                print("   ", tw["url"])
        since = started - 60                  # small overlap; the seen set removes repeats
        time.sleep(INTERVAL)


if __name__ == "__main__":
    main()

Researching this?Free starter credits cover end-to-end testing — Google sign-in, no card. Get a key.

10 — Questions

Questions readers ask

How much does Kiro cost?

Kiro Free is $0 with 50 credits a month. Paid plans are Pro $20 (1,000 credits), Pro+ $40 (2,000), Pro Max $100 (5,000) and Power $200 (10,000), per user per month in US dollars, taxes excluded. Extra credits on paid plans cost $0.04 each. Teams pool credits at $20 per seat with 500 credits per seat.

Is Kiro free?

Kiro has a perpetual free tier with 50 credits a month, open-weight models and Claude Sonnet 4.5 with limits. Your first upgrade from Free to Pro also makes the rest of that month free and adds 500 trial credits usable within 12 months, and verified students at eligible universities get a year with 1,000 credits a month.

What happens when I run out of Kiro credits?

Kiro uses plan credits first, then trial credits, then add-on credits. When none are left, requests pause until your plan credits reset at the start of the next month, or until you buy add-on credits ($0.04 each, packs from $5 for 125) or upgrade. Free accounts cannot buy add-ons.

Does Kiro still have overage billing?

For individual plans, extra usage is now bought as prepaid add-on credits at $0.04 each. Overage, an opt-in setting at the same $0.04 rate when credit plans launched in September 2025, continues only for existing Enterprise customers on the individual tiers; team credit pooling does not use overages.

Do unused Kiro credits roll over?

Plan credits do not: they reset at the start of each billing month. Add-on credits and trial credits do carry over and expire 12 months after you get them. In a team pool, included credits expire at the end of each month.

Is Kiro CLI priced separately from the IDE?

No. One Kiro subscription covers the IDE, kiro-cli, Kiro Web, Kiro Crew, ACP-compatible IDEs and CI/CD runs, all drawing on the same credits. Headless CLI runs with an API key need Pro, Pro+, Pro Max or Power.

Which Kiro model uses the fewest credits?

Against Auto at 1.0x, Qwen3 Coder Next is 0.05x, MiniMax M2.1 0.15x, DeepSeek 3.2 and MiniMax M2.5 0.25x, and Claude Haiku 4.5 0.4x. Claude Opus 5.5 is 2.0x and GPT-5.6 Sol 4.4x. Actual credits per task also depend on tokens, thinking depth and reasoning effort.

How do I add Twitter (X) data to Kiro, and what does it cost?

Add the TwitterAPI.io hosted MCP server (https://mcp.twitterapi.io/mcp, API key as a Bearer token) to .kiro/settings/mcp.json. Kiro bills the agent work in its credits; the X reads are billed by TwitterAPI.io at $0.15 per 1,000 tweets returned, against $5.00 at the official X API's $0.005 per post read.

11 — Further reading

Continue

Sources & further reading
More from this series

Writing about something you built with TwitterAPI.io? Our community rewards program pays API credits for honest tutorials, build logs and videos.

Build it

Stop reading. Start building.

Starter credits cover real testing on real data. Google sign-in, no card, no application queue.

Get an API key

Already building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.