Grok Imagine Limit: Daily Caps and a Pay-per-Use API (2026)

The Grok Imagine limit is the cap xAI sets on how many images and videos you can generate in the Grok app and on X before a “limit reached” message makes you wait. It depends on your plan and resets on a timer, and it has changed several times in 2026, usually getting smaller. This post covers the numbers users are reporting, how the reset windows work, what helps when you hit the wall, and how to run the same Grok models through an API, where you pay per request and don’t wait for a window to reopen.

What is the Grok Imagine limit?

Grok Imagine is xAI’s image and video generator. It lives inside Grok and is also available on X. Every account gets an allowance of generations, and the Grok Imagine limit is the point where that allowance runs out. The plans market it as generous, and some even promise “near unlimited usage”. In practice, people who use it heavily hit caps fairly quickly.

Two ideas help explain how the caps behave:

• Quota: a fixed number of generations you can make in a period, such as 50 images per day.
• Rolling window: a period measured back from right now, not from midnight. With a 24-hour rolling window, an image you made at 3 pm today counts against you until 3 pm tomorrow.

xAI also adjusts limits on the fly. Users report that caps vary with account behaviour, region and server load. Two people on the same plan can see different numbers on the same day, and the published tier descriptions don’t always match what you experience.

Images, videos and edits count separately

The Grok Imagine limit is not one number. Image generations, video generations and image edits each have their own counter, and higher-resolution video (720p and up) has been reported to have a tighter cap of its own. Chat messages are separate again. When you run out of one, the others may still work.

Grok Imagine limits by plan

xAI changes these numbers often, and the figures below come from what users report, not from a fixed public spec. Use them as a rough guide to what each tier gives you.

Plan	Reported image cap	What users report about video and edits
Grok Free	About 5 images per day	Most restricted; video access is thin and throttles quickly
SuperGrok Lite	About 20 images per day	Lower video and edit allowances than full SuperGrok
SuperGrok	About 50 images per day	Highest standalone tier; video caps cut during 2026
X Premium+	Includes SuperGrok	Same Imagine access as SuperGrok, bundled with X features

Video is where most of the frustration comes from. On Reddit, Grok Imagine users describe SuperGrok moving from 100 videos in a 2-hour window to 50 videos in 24 hours. If you used every 2-hour window, the old cap worked out to about 24 times more videos per day. Other reports from 2026 describe:

• Video, image and voice features throttling after 20 to 30 minutes of continuous use.
• The daily edit allowance falling from roughly 100 to about 30 overnight.
• 720p generations capped inside a 12-hour window, while 480p kept a looser allowance.
• Heavier moderation, so more prompts get refused.

This is also why searches like “grok imagine no longer free” keep coming back. Each time free features are trimmed, people go looking for answers. The safe assumption is that a consumer plan’s Grok Imagine limit can shrink without warning, so don’t build a workflow that depends on today’s numbers.

When does the Grok Imagine limit reset?

The most common report is that image generation allowances reset every 24 hours. Video and high-resolution caps have used shorter windows at various times: 2 hours, then 12 hours for 720p, and then a 24-hour count for video on SuperGrok.

Because these are rolling windows, there is usually no single reset time. Each generation stops counting against you a fixed time after you made it. If you made 50 images between 9 am and 10 am, capacity comes back gradually between 9 am and 10 am the next day. You don’t get all 50 back at midnight.

How to estimate your own reset

1. Note the time of the first generation in a session.
2. When you hit the limit, add the window length (usually 24 hours for images) to that first timestamp.
3. Expect capacity to come back in the same order you used it.

There is no official Grok rate-limit checker that shows your remaining count in real time. Third-party “checkers” can only guess. The app’s limit message, which sometimes includes an upgrade prompt or a wait time, is the most reliable signal you have.

“Image limit reached”: what helps and what doesn’t

Most “fix” videos about the Grok Imagine limit boil down to waiting or paying. Here is what actually makes a difference.

Things that help

• Plan your prompts before you generate. Write the subject, style, lighting and aspect ratio in one go. Every vague first attempt costs a generation.
• Draft at low resolution. If 480p video has a looser cap than 720p, use it to test motion and composition, and switch to 720p only for the version you’ll keep.
• Work from variations. Grok Imagine returns several images per prompt. Pick the best one and refine it instead of rerunning the whole prompt.
• Upgrade if the app is your main tool. Going from Free to SuperGrok Lite or SuperGrok is the only official way to raise the cap.
• Move bulk work to an API. If you need dozens of assets a day on a schedule, a per-request API removes the daily counter altogether. More on that below.

Things that don’t help (or cause trouble)

• Clicking regenerate over and over. Each attempt counts, and rapid repeats seem to trigger throttling sooner.
• Clearing the cache or logging out. The limit is tied to your account on the server, not to your browser.
• VPNs and extra accounts. Limits vary by region, but switching regions or running several accounts to dodge caps can break the terms of service and put your account at risk.
• Rewording refused prompts again and again. Refusals can still use up attempts, and repeated policy hits may lead to stricter handling of your account.

A note on Grok Imagine spicy mode

Grok Imagine spicy mode is a consumer app setting for looser content, and it comes with the same throttling and tighter moderation described above. People often ask whether an API gives the same setting. Don’t assume it does. API access is governed by the provider’s content policies, so check them before you plan a project around specific content.

Using a Grok Imagine API instead of the app limit

If your problem is volume, such as product shots, social clips, or batch content for a client, a consumer subscription is the wrong tool. A Grok Imagine API meters each request. Your credit balance becomes the limit, not a counter that resets every 24 hours, and you can run jobs from a script, a backend or a scheduled task.

Unicorn API gives you every Grok Imagine model, plus other image, video, audio and chat models, through one API key and one bill. Prices are in credits. On a monthly plan a credit costs $0.01 (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-up credits cost $0.015 each and never expire. Plans are listed on the pricing page.

Model	What it does	Price in credits
Grok Imagine	Text-to-image; 6 variations per prompt (2 with reference images); aspect ratios 1:1, 2:3, 3:2, 16:9, 9:16	4 per request; multiplied by n when set
Grok Imagine Video 1.5	Image-to-video only; animates a start frame for 1 to 15 seconds at 480p, 720p or 1080p	6 s at 720p: 27; 10 s at 720p: 45; 10 s at 1080p: 80
Grok Imagine Video 1.0	Text-to-video or image-to-video, 6 to 30 seconds, same per-second rate as 1.5	6 s at 720p: 27; 20 s at 720p: 90; 30 s at 1080p: 240
Grok Imagine Upscale	Upscales an earlier Grok generation by its task_id	720p: 10; 1080p: 20

Video prices are per second: 2.4 credits a second at 480p, 4.5 at 720p and 8 at 1080p. The total is rounded up to whole credits, so a 6-second 480p clip (14.4) is billed as 15 credits. You don’t need to work this out yourself. POST /v1/models/price returns the exact price of any request before you run it. The API documentation covers that endpoint and the full request reference.

One trade-off to know about: Grok Imagine Video 1.5 can be busy at peak times. Its per-second rate is very low and its motion quality is strong, but if a deadline depends on it, plan for queue time. The trade with an API is that you swap a daily cap for a per-request cost. For light, occasional use, the consumer app may still work out cheaper.

Worked example: generate an image and animate it

This example makes a 16:9 start frame with Grok Imagine and animates it into a 6-second 720p clip with Grok Imagine Video 1.5. Total cost is 4 + 27 = 31 credits, which is $0.31 at plan pricing. Create a key on the API keys page and export it as UNICORN_API_KEY.

Step 1: submit an image job with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed",
      "aspect_ratio": "16:9"
    }
  }'

The response contains a job ID. Media jobs run asynchronously, which means the request returns right away and the image is generated in the background. Poll GET /v1/jobs/{id} until status is "succeeded", then read the image URL from outputs[0].url. The other variations are in the rest of the outputs array.

Step 2: the full pipeline in Python

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}


def run_job(model, input_, timeout=600):
    r = requests.post(f"{API}/v1/jobs", headers=HEADERS,
                      json={"model": model, "input": input_})
    r.raise_for_status()
    job_id = r.json()["id"]

    deadline = time.time() + timeout
    while time.time() < deadline:
        job = requests.get(f"{API}/v1/jobs/{job_id}", headers=HEADERS).json()
        if job["status"] == "succeeded":
            return job
        if job["status"] == "failed":
            raise RuntimeError(f"Job {job_id} failed: {job}")
        time.sleep(3)
    raise TimeoutError(f"Job {job_id} did not finish in {timeout}s")


# 1. Start frame: 4 credits, returns several variations
image_job = run_job("grok-imagine", {
    "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed",
    "aspect_ratio": "16:9",
})
start_frame = image_job["outputs"][0]["url"]
print("Start frame:", start_frame)

# 2. Animate it: 6 seconds at 720p = 27 credits
video_job = run_job("grok-imagine-video-1-5-preview", {
    "image": start_frame,
    "prompt": "The fox lifts its head and looks toward the rising sun, snow drifting gently",
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9",
})
print("Video:", video_job["outputs"][0]["url"])

A few notes on adapting this:

• Choose a variation on purpose. The script takes the first output. In a real tool, show all the variations and let a person (or a scoring step) pick one before you spend 27 credits animating it.
• Draft cheaply. Set "resolution": "480p" while you test motion prompts. A 6-second draft costs 15 credits, against 27 at 720p.
• Need longer clips or text-to-video? Switch the model to grok-imagine/image-to-video (Video 1.0), which runs from 6 to 30 seconds and also accepts a prompt with no start frame.
• Save outputs right away. Download each file to your own storage so your library doesn’t depend on how long the URLs last.

If you’d like to try prompts before writing code, the browser playground runs the same models. To call the API from Cursor or Claude Code, see using the API from agents. For more on clip length and video settings, read our guide to creating Grok Imagine videos.

What does a month of Grok Imagine cost in credits?

This is the comparison that matters once the Grok Imagine limit starts getting in the way: how much work a given budget buys when nothing resets on a timer. The figures below use plan credits at $0.01 each.

Plan (credits)	Grok Imagine image requests (4 each)	6 s 720p videos (27 each)	10 s 1080p videos (80 each)
Starter, $25 (2,500)	625	92	31
Creator, $50 (5,000)	1,250	185	62
Studio, $100 (10,000)	2,500	370	125
Pro, $200 (20,000)	5,000	740	250

Each image request returns several variations, so the number of usable images is higher than the request count. In practice you’ll mix models: a batch of start frames, a few drafts, and final renders. All of it comes out of the same credit balance.

Other image models when Grok isn’t the right fit

The same key also works with other image models, which helps when Grok’s style or moderation doesn’t suit the job:

• Nano Banana 2 Lite (4 credits per image): Google’s cheapest Gemini image model, fast at 1K resolution, with edits that accept up to 10 reference images.
• GPT Image 1.5 (3 credits low, 4 medium, 22 high): reliable prompt adherence and legible text, with an optional transparent background, which suits product cut-outs and graphics with lettering.

Common mistakes and trade-offs

Whether you stay in the app or move to an API, these are the mistakes that waste the most generations and money.

1. Treating reported limits as guarantees. Every Grok Imagine limit quoted online, including the ones in this post, is a snapshot. If your business depends on a consumer cap staying where it is, you’re taking a risk.
2. Animating before you pick the frame. The start frame shapes most of how the video looks. Spending a few extra 4-credit image requests to get the frame right costs less than re-rendering video.
3. Rendering finals at 1080p by default. A 10-second clip costs 80 credits at 1080p and 45 at 720p. If your target is a phone screen, 720p is often enough, and Grok Imagine Upscale can lift a chosen clip later for 10 or 20 credits.
4. Ignoring peak-time queues. Video 1.5 can be busy. Build retries and a timeout into your polling, as in the script above, rather than assuming a fixed turnaround.
5. Skipping the price check. Odd durations and rounding can surprise you. Call /v1/models/price once for each new setting before you run a batch.
6. Paying twice for the same use case. If you only make a handful of images a week, a consumer plan’s cap may never bite. The API makes sense once you’re automating, batching, or routinely hitting the Grok Imagine limit before lunch.

The short version: the in-app Grok Imagine limit is built for casual use, and it keeps getting tighter. For predictable, scriptable volume, run the same models by the request and pay only for what you generate. You can browse every available model in the full model catalog.