Picasso AI API: Image and Video API Pricing, Key and Docs

If you searched for a Picasso AI API, you probably want three answers before you write any code: what it costs, how you authenticate, and what the docs let you call. The short version: PicassoIA runs a Replicate-style REST API at https://api.picassoia.com/v1, it authenticates with a bearer token that starts with pia_sk_, it exposes four models for images and video, and its docs state that API predictions are currently free. The catch is a plan requirement, and it is worth reading before you build anything on top of it. This article follows the order you will meet things in practice: pricing, credential setup, your first request, the limits, video, and the MCP connector that shares the same four models.

What the PicassoIA API Offers

The PicassoIA API page describes a small, focused surface. You send a request to create a prediction, the job runs on PicassoIA's own GPUs, and you poll until the result is ready. There are no SDKs to install, and the code samples in the docs use plain HTTP in cURL, Python and Node.

Base URL and Authentication

Every call goes to one base URL and carries one header:

Base URL:      https://api.picassoia.com/v1
Header:        Authorization: Bearer pia_sk_...
Content-Type:  application/json

Copy Prompt

The pia_sk_ prefix marks a secret token. Treat it like a password, because anyone who holds it can spend your plan's capacity.

The Four Models

The web catalog lists more than 250 image, video and chat models. The API exposes four of them:

💡 Worth knowing: the API reference also offers GET /v1/models, which returns every model with its input schema. Read it once instead of guessing parameter names from examples.

Endpoints at a Glance

Who This API Fits

Four models and five slots suit a specific kind of project. It works well for content pipelines that turn a spreadsheet of product names into banner images, for small apps that add a "make an image" button, for editorial teams that need a steady trickle of header pictures and short video loops, and for scripts that run overnight while nobody is waiting. It fits less well when you need a particular third-party model, a chat endpoint, or hundreds of simultaneous users, because the ceiling is per account and the model list is fixed.

API Pricing and Plan Requirements

Free Predictions, With a Catch

The docs say it plainly: "API predictions are currently free. They use no credits." That removes the usual per-call arithmetic. Most hosted image and video APIs bill per call or per second of output, so a bug that loops costs money. Here the same bug costs you throughput instead, because of the five-prediction ceiling described below.

The catch is the plan. According to the API reference, an Infinite plan is required to create predictions. Reading, listing and canceling work without it, so you can test your token and your client code on a lower tier, but the first POST that creates a job needs Infinite.

Reading the Pricing Page

The pricing page adds a second signal. It lists API Access and MCP Connections as features on the paid tiers (Pro+, Elite and Infinite), each with a "New" badge, but it says nothing about whether API calls use credits. So you have two statements that do not fully line up:

💡 Practical rule: treat the API page as the authority for creating predictions, then confirm on your own account before you promise anything to a client. Plan prices change, so read the current Infinite price on the pricing page instead of trusting a number copied into an article.

Because the word "currently" sits in the docs, build your integration so a cost can be added later: log every prediction ID, model and output size from day one. If billing ever arrives, you will already have the usage data.

Create and Protect Your Credential

Create a Token in Your Account

1. Sign in to PicassoIA and open the API section of your account.
2. Create a new token. It starts with pia_sk_.
3. Copy it immediately. It is shown once at creation and cannot be retrieved later, so a lost token means creating a new one.
4. Store it in a password manager or a secrets vault before you close the dialog.

Each account can hold at most 2 tokens. That limit looks tight, but it fits a clean rotation habit, explained next.

Keep It Out of Your Code

Put the token in an environment variable and read it at runtime. The examples below use PICASSOIA_API_TOKEN, a name chosen for this article, not one the platform requires.

• Server side only. Never ship the token in browser JavaScript or a mobile app. Anyone can read it from the network tab.
• Rotate with the second slot. Create token two, deploy it, confirm traffic works, then revoke token one. You never have a gap.
• Never commit it. Add .env to your ignore file and scan old commits if you slipped once.
• Use one token per environment when you can: production on one slot, staging on the other.

Your First Request, Step by Step

💡 Before you copy anything: the API follows the Replicate pattern, so the examples use the field names that pattern implies (id, status, output). Print the first response you receive once and check those names before you wire this into production.

Send the Prediction

export PICASSOIA_API_TOKEN="pia_sk_your_token_here"

curl -X POST https://api.picassoia.com/v1/models/picassoia/picassoia-image/predictions \
  -H "Authorization: Bearer $PICASSOIA_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"input": {"prompt": "a lighthouse at sunset", "aspect_ratio": "16:9"}}'

Copy Prompt

The call returns quickly with a prediction object. The picture does not exist yet: the job is queued and runs asynchronously.

Poll Until It Finishes

curl https://api.picassoia.com/v1/predictions/PREDICTION_ID \
  -H "Authorization: Bearer $PICASSOIA_API_TOKEN"

Copy Prompt

Repeat every few seconds until the status reads succeeded or failed. A failure is final, so resubmit with a new prediction instead of waiting. When it succeeds, the output holds the image URLs. Save the files you care about to your own storage rather than hotlinking result URLs.

Log the full response body whenever a prediction fails, along with the prompt and the model ID. Most failures trace back to a prompt that is too long, an image that is too large or a malformed input object, and the saved response tells you which one in seconds. Add a hard timeout of your own, for example two minutes for an image and ten for a video, then call the cancel endpoint so a stuck job does not hold one of your five slots.

Python and Node Versions

import os, time, requests

BASE = "https://api.picassoia.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['PICASSOIA_API_TOKEN']}"}

def generate(prompt):
    r = requests.post(
        f"{BASE}/models/picassoia/picassoia-image/predictions",
        json={"input": {"prompt": prompt, "aspect_ratio": "16:9"}},
        headers=HEADERS,
        timeout=30,
    )
    r.raise_for_status()
    prediction = r.json()

    while prediction["status"] not in ("succeeded", "failed", "canceled"):
        time.sleep(3)
        prediction = requests.get(
            f"{BASE}/predictions/{prediction['id']}", headers=HEADERS, timeout=30
        ).json()
    return prediction

Copy Prompt

const BASE = "https://api.picassoia.com/v1";
const headers = {
  Authorization: `Bearer ${process.env.PICASSOIA_API_TOKEN}`,
  "Content-Type": "application/json",
};

export async function generate(prompt) {
  const res = await fetch(`${BASE}/models/picassoia/picassoia-image/predictions`, {
    method: "POST",
    headers,
    body: JSON.stringify({ input: { prompt, aspect_ratio: "16:9" } }),
  });
  let prediction = await res.json();

  while (!["succeeded", "failed", "canceled"].includes(prediction.status)) {
    await new Promise((r) => setTimeout(r, 3000));
    prediction = await (await fetch(`${BASE}/predictions/${prediction.id}`, { headers })).json();
  }
  return prediction;
}

Copy Prompt

Limits That Shape Your Design

Five Predictions at Once

The ceiling is per account, not per token. If a cron job, a web app and an MCP session all run together, they draw from the same five slots. Put a limiter in front of your client, such as a semaphore or a worker pool of five, and queue the rest yourself.

Throughput is easy to estimate. If one image prediction takes N seconds from submit to succeeded, five slots give you roughly 5 / N images per second, and a batch of 500 images takes about 500 × N / 5 seconds. Measure N over your first ten calls, then size nightly batches from that number instead of a guess. Video jobs run longer, so run them in their own queue and keep one or two slots free for images.

Three mistakes show up again and again:

• Launching a whole batch at once. Fifty simultaneous POST calls means forty-five rejected or stalled ones.
• Forgetting the MCP sessions. A teammate generating images through the connector eats into your five.
• Retrying instantly on failure. Wait a few seconds so you do not fill the slots with doomed retries.

Size and Prompt Caps

A prompt can run to 4,000 characters, which is roomy enough for the long, detailed prompts that photorealistic work needs. The tighter constraint is image input. Each data URL image can reach 5 MB, yet the whole request body stops at 10 MB, so four near-limit images in one editing call will not fit. Downscale to a sensible width and compress to JPEG before you encode.

Video Through the API

PicassoIA Video Settings

PicassoIA Video accepts text or an image and returns a single MP4. The reference ties the maximum duration to the resolution:

Pick the lowest resolution that meets the brief. A 480p draft gives you four times the length of a 1080p render, which suits social loops and storyboards. Video jobs take longer than image jobs, so poll every 8 to 10 seconds, not every 3.

Seedance 2.5 Lite With Audio

Seedance 2.5 Lite adds synchronized audio to the clip, which saves a separate sound step. The API reference lists durations of 5, 10 and 15 seconds, while the web catalog describes clips of up to 10 seconds, so read the schema from GET /v1/models before you hard-code an allowed value. The larger Seedance 2.5 stays in the browser catalog and is not part of the API.

MCP and Chat Models Beside the API

The MCP connector gives AI assistants the same four models without any HTTP code. The claude.ai connector exposes tools for generating images, editing images, creating video with either video model, and managing jobs: generate_image, edit_image, generate_video_picassoia, generate_video_seedance, get_generation, list_generations, list_models, get_account and cancel_generation.

The flow mirrors the REST one. A generate tool returns a prediction ID and an estimated time as soon as a GPU accepts the job. You then call get_generation after the suggested delay, and again after each delay it returns, until the status is succeeded or failed. cancel_generation stops a job that has not started rendering. Concurrency is the same shared five.

Chat models are a separate matter. None of the four API models writes text, so large language models live in the browser: Claude Sonnet 5 for long drafting, GPT 5.6 Sol for hard coding problems and Gemini 3.5 Flash when speed matters. A good workflow is to draft and refine a prompt with one of them, then paste the result into your API call. Models such as GPT Image 2, Flux 2 Pro, Veo 3.1 and Kling v3 Video also sit in the browser catalog only.

How to Use PicassoIA Image on PicassoIA

Test every prompt in the browser before you script it. A bad prompt costs nothing there, and the same ideas carry straight into the API call.

1. Open the PicassoIA Image page and sign in.
2. Write the prompt in this order: subject and action, setting, light, camera and lens, texture details.
3. Choose the aspect ratio. 16:9 suits banners and blog headers, 1:1 suits product tiles. The API takes the same aspect_ratio field.
4. Set the image count to 1 or 2, which matches the API's range.
5. Generate, then review the result at full size, looking at hands, edges and any stray text.
6. Send the best image to PicassoIA Image Editor Pro to fix a detail or combine it with up to three more pictures.

Ready to try it yourself? Open PicassoIA Image, write the prompt you would have sent in your first API call, and watch it render. Once the result looks right, copy the same prompt into the cURL example above and let your own code do the rest. If you want to browse everything else the platform can do, the full model catalog is one click away.