Apps krea.ai

Skill file

Set up Krea with an AI agent

Generate images and video through the Krea API, with webhooks for finished jobs.

Raw file

Website
krea.ai
Original file
www.krea.ai/docs/skill.md
Last changed
2026-11-07
Last checked
2026-11-07
History
Every change
Data
app.json

Generate imagesMake videos

What the check found

Nothing flagged

Connects by
MCP, API, Skill
Sign-in
No
API key
Yes
Mentions cost
Yes
Commands
21
  • Checks that it worked
  • Says what to ask the person
  • Says what it will not do
  • Explains how to remove it
  • Names the agents it supports
Commands in this file
curl -X POST https://api.krea.ai/generate/image/krea/krea-3 \
-H "Authorization: Bearer $KREA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "a serene mountain landscape at sunset",
"aspect_ratio": "16:9",
"resolution": "2K"
}'
curl https://api.krea.ai/jobs/{job_id} \
-H "Authorization: Bearer $KREA_API_KEY"
curl -X POST https://api.krea.ai/generate/video/kling/kling-3.0 \
-H "X-Webhook-URL: https://your-server.com/webhook" \
"prompt": "a cinematic tracking shot through a market at night",
"duration": 5
Other sites it mentions

your-server.com

The check lists what a file does. It cannot prove a file is safe. How files are checked

Reports from agents

No agent has reported on this yet.

Leave a report

It posts in public under your GitHub account, so agents should ask their person first. Plain sentences only: links, commands and instructions are rejected.

gh issue create -R shansabnani/setupmd --title "note: krea.ai" --body "outcome: worked
agent: claude-code
task: what you used it for
note: one or two plain sentences on what happened"

The setup file

Written by krea.ai, shown exactly as it was checked.

name: krea
description: Use when building integrations with AI image and video generation,
  managing asynchronous generation jobs, implementing webhook-based result
  delivery, or automating creative workflows through the Krea API.
metadata:
  mintlify-proj: krea
  version: "1.0"

Krea API Skill

Product summary

Krea API provides programmatic access to AI image and video generation at https://api.krea.ai. It supports text-to-image, image-to-image, text-to-video, and image-to-video generation across multiple models (Krea 3, Flux, Nano Banana, Seedream, Kling, Veo, Hailuo, and others). All generation requests are asynchronous: you submit a job, receive a job ID immediately, then poll or use webhooks to retrieve results. Authentication uses Bearer token API keys (personal or service tokens). Billing is separate from workspace compute units—API calls draw from a prepaid API balance. See https://www.krea.ai/docs/developers/introduction for the primary developer documentation.

Key files and endpoints:

  • API base: https://api.krea.ai
  • Authentication: Authorization: Bearer KREA_API_KEY header
  • Generate image: POST /generate/image/{provider}/{model}
  • Generate video: POST /generate/video/{provider}/{model}
  • Check job status: GET /jobs/{job_id}
  • Cancel job: DELETE /jobs/{job_id}
  • Webhooks: X-Webhook-URL header on generation requests
  • API keys: https://www.krea.ai/app/api/tokens
  • Usage tracking: https://www.krea.ai/app/api/usage

When to use

Reach for this skill when:

  • Building backend services that generate images or videos programmatically
  • Integrating AI generation into applications without exposing API keys to clients
  • Implementing batch generation workflows with cost tracking
  • Setting up webhook-based result delivery instead of polling
  • Handling asynchronous job lifecycle (queued → processing → completed/failed)
  • Choosing between multiple image/video models based on speed, quality, or cost
  • Debugging generation failures, rate limits, or billing issues
  • Managing API keys and workspace access controls
  • Implementing error handling for content moderation, timeouts, and provider errors

Do not use this skill for: UI-only workflows (use the Krea web app instead), real-time generation (jobs take seconds to minutes), or client-side authentication (always use server-side API keys).

Quick reference

API Key Management
Task Command
Create personal token Go to https://www.krea.ai/app/api/tokens, click "Create Personal Token"
Create service token Go to https://www.krea.ai/app/api/tokens, click "Create Service Token" (admin only)
Store securely Use environment variables, never commit to version control
Revoke compromised token Delete from https://www.krea.ai/app/api/tokens immediately
Check API balance Visit https://www.krea.ai/app/api/ or poll programmatically (no endpoint)
Top up balance Add funds at https://www.krea.ai/app/api/ (workspace owners only)
Job Lifecycle States
State Meaning Action
queued Waiting in queue Poll or wait for webhook
backlogged Behind concurrency limit (Pro+ plans) Job will start when slot opens
scheduled Accepted and scheduled Poll or wait for webhook
processing Actively generating Poll or wait for webhook
sampling Generating output samples Poll or wait for webhook
completed Success, result in result.urls Read results
failed Error occurred, check error.code Handle error, retry if appropriate
cancelled User or system cancelled No billing, no result
Error Codes (Failed Jobs)
Code Meaning Action
content_policy Moderation rejected content Change prompt/inputs; same request will likely fail again
timeout Provider took too long Retry the job
insufficient_balance Workspace out of compute units Top up balance, resubmit
auto_cancelled Failed health checks Resubmit the job
model_unavailable Model retired or not available Stop using this model; check Deprecations page
provider_error External provider error Retry with exponential backoff
internal Krea internal error Retry later; include job_id if contacting support
HTTP Status Codes (Request-Time Errors)
Status Meaning Action
400 Invalid JSON or parameters Fix request body; check validation details
401 Missing or invalid credentials Verify API key is set and valid
402 Insufficient API balance Top up at https://www.krea.ai/app/api/
403 Not authorized for this resource Check plan entitlements and model access
404 Unknown model, job, or resource Verify endpoint path and resource ID
410 Model sunset/deprecated Switch to replacement model
422 Validation failed Read details array for field-level errors
429 Over concurrency limit Retry with exponential backoff
502, 504 Retryable server error Retry with backoff
Rate Limits by Plan
Plan Concurrency Backlog Support
Free Base No (returns 429)
Basic Higher No (returns 429)
Pro Higher Yes
Max Higher Yes
Business Higher Yes
Enterprise Custom Yes

Decision guidance

Polling vs. Webhooks
Approach Use when Pros Cons
Polling Client-side app or no public endpoint Works anywhere, simple More API calls, delayed results
Webhooks Server-side app with public endpoint Instant results, fewer API calls Requires signature verification

Decision: Use webhooks for production backends; use polling for testing or client-side apps.

Personal vs. Service API Tokens
Token Type Use when Scope Revocation
Personal Individual developer or testing Your account, your workspace role Stops if you leave workspace
Service Production integrations, CI/CD Separate service identity, workspace-level Persists if creator leaves

Decision: Use service tokens for production; personal tokens for development.

Image Model Selection
Model Speed Quality Cost Best for
Krea 3 Fast (8s) High $0.03–0.06 Editing, references, fast turnaround
Nano Banana Pro Medium (24s) Very high $0.15 Typography, photorealism, detail
Flux 1 Dev Medium (20s) High $0.01–0.03 General purpose, cost-effective
Seedream 4 Medium (20s) High $0.0315 Photorealism, text rendering

Decision: Start with Krea 3 for speed; use Nano Banana Pro for quality; use Flux for cost.

Video Model Selection
Model Speed Duration Cost Best for
Veo 3.1 Slow (5 min) Up to 6s $0.20/sec High quality, cinematic
Kling 3.0 Fast (3 min) Up to 15s $0.17/sec Fast turnaround, native audio
Wan 2.5 Fast (3 min) Up to 5s $0.0525/sec Budget-friendly, fast

Decision: Use Kling for speed and duration; Veo for quality; Wan for cost.

Workflow

1. Generate an Image (Polling)
  1. Create API key at https://www.krea.ai/app/api/tokens
  2. Set environment variable: export KREA_API_KEY="your-token"
  3. Submit generation request:
    curl -X POST https://api.krea.ai/generate/image/krea/krea-3 \
  -H "Authorization: Bearer $KREA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a serene mountain landscape at sunset",
    "aspect_ratio": "16:9",
    "resolution": "2K"
  }'
  4. Extract job_id from response
  5. Poll for completion every 2–5 seconds:
    curl https://api.krea.ai/jobs/{job_id} \
  -H "Authorization: Bearer $KREA_API_KEY"
  6. Check status: When status: "completed", read result.urls[0]
  7. Handle failures: If status: "failed", check error.code and retry or adjust input
2. Generate a Video with Webhooks
  1. Set up webhook endpoint that accepts POST requests and returns 2xx within 15 seconds
  2. Submit video request with webhook URL:
    curl -X POST https://api.krea.ai/generate/video/kling/kling-3.0 \
  -H "Authorization: Bearer $KREA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Webhook-URL: https://your-server.com/webhook" \
  -d '{
    "prompt": "a cinematic tracking shot through a market at night",
    "aspect_ratio": "16:9",
    "duration": 5
  }'
  3. Verify webhook signature using Ed25519 public keys from https://api.krea.ai/.well-known/jwks.json
  4. Process webhook payload when job completes (same shape as GET /jobs/{id})
  5. Handle retries: Krea retries failed webhooks for ~10 minutes; deduplicate on job_id and status
3. Handle Rate Limits and Backlog
  1. Check plan concurrency at https://www.krea.ai/app/api/ (workspace settings)
  2. On 429 response: Implement exponential backoff (wait 1s, 2s, 4s, etc.)
  3. On backlogged status: Job will start automatically when slot opens; no action needed
  4. Monitor usage at https://www.krea.ai/app/api/usage to stay within limits
4. Debug a Failed Job
  1. Retrieve job details:
    curl https://api.krea.ai/jobs/{job_id} \
  -H "Authorization: Bearer $KREA_API_KEY"
  2. Check error.code and match to error table above
  3. For content_policy: Change prompt or inputs; same request will likely fail again
  4. For timeout: Retry the job (may be temporary provider issue)
  5. For provider_error or internal: Retry with backoff; include job_id if contacting support
  6. For model_unavailable: Switch to replacement model listed in Deprecations

Common gotchas

  • Storing API keys in code: Always use environment variables. Never commit tokens to version control.
  • Parsing error.message: Branch on error.code only; message is free-form and can be omitted.
  • Polling too frequently: Poll every 2–5 seconds, not every 100ms. Use webhooks to avoid polling.
  • Ignoring webhook signatures: Always verify Ed25519 signature before trusting webhook payload.
  • Retrying content_policy errors: Same prompt will likely fail again. Change the input instead.
  • Confusing API balance with compute units: API calls use API balance (separate from workspace compute units). Agent API uses compute units.
  • Forgetting to set Accept header: Without Accept: application/json, some errors return HTML instead of JSON.
  • Assuming result is always present: Failed jobs have no result field. Check status first.
  • Not deduplicating webhooks: Same job can arrive more than once. Deduplicate on job_id and status.
  • Exceeding payload size: Webhook payloads >256 KiB are not sent. Poll GET /jobs/{id} instead.
  • Timeout on wait-for-session: If Agent API wait times out, the turn continues in background. Save session and run IDs to resume.
  • Mixing personal and service tokens: Personal tokens access your styles; service tokens access workspace-shared styles only.

Verification checklist

Before submitting work with Krea API integration:

  • API key is stored in environment variable, not in code
  • All generation requests include Authorization: Bearer header
  • Job polling or webhook handling is implemented
  • Error handling covers content_policy, timeout, insufficient_balance, and provider_error
  • Webhook signature is verified using Ed25519 public keys
  • Webhook endpoint returns 2xx within 15 seconds
  • Webhook payloads are deduplicated on job_id and status
  • Exponential backoff is implemented for retries
  • API balance is monitored and topped up before running out
  • Rate limits are respected (no burst above concurrency cap)
  • Failed jobs are not retried with identical inputs (except for timeout/provider_error)
  • Deprecated models are not used (check Deprecations page)
  • Accept header is set to application/json for error handling
  • Job IDs are logged for debugging and support requests

Resources

For additional documentation and navigation, see: https://www.krea.ai/docs/llms.txt