DEV Community: PopNow

Generate AI images, videos and music from Claude Code, Cursor or VS Code with one remote MCP server

PopNow — Thu, 05 Nov 2026 10:38:45 +0000

Coding agents are good at writing the landing page. They're bad at the parts that aren't code: the hero image, the 5-second product loop, the background track for the demo video. Usually you leave the editor, open three different generator sites, download files, and drag them back into public/.

This tutorial connects one remote MCP server to your agent so it can make those assets itself, inside the same session. I'll use PopNow's hosted server because it covers image, video, music and speech behind one sign-in, but most of what follows (OAuth discovery, quote-then-confirm, async jobs) applies to any paid, hosted MCP server.

Disclosure: I work on PopNow. Everything below works with a normal PopNow account; prices are in the table near the end with sources.

What you'll have at the end

A remote MCP server connected to Claude Code, Cursor or VS Code (no local process, no API key in a config file)
An agent that can call create_image, create_video, create_music and create_speech
A small workflow: "build a landing page and make its hero video" in one prompt

1. Connect the server

The server URL is https://api.popnow.ai/mcp. It speaks Streamable HTTP and signs you in with OAuth 2.1, so there is nothing to install.

Claude Code

claude mcp add --transport http popnow https://api.popnow.ai/mcp

Then run /mcp inside Claude Code, pick popnow and authenticate. A browser tab opens, you sign in and press Allow.

Cursor (.cursor/mcp.json in the project, or ~/.cursor/mcp.json globally)

{
  "mcpServers": {
    "popnow": { "url": "https://api.popnow.ai/mcp" }
  }
}

VS Code (.vscode/mcp.json; note the top-level key is servers)

{
  "servers": {
    "popnow": { "type": "http", "url": "https://api.popnow.ai/mcp" }
  }
}

Claude on the web or desktop: Customize → Connectors → Add custom connector, name it PopNow, paste the URL, leave the advanced OAuth fields empty.

Configs for Windsurf, Cline, Codex CLI and others are in the popnow-mcp repo.

2. What actually happens during sign-in

If you've only used local stdio servers, remote OAuth can feel like magic. It isn't, and knowing the steps makes debugging much easier. You can replay them with curl.

Step 1: the client calls the server without a token and gets a 401.

curl -i -X POST https://api.popnow.ai/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
# HTTP/2 401
# www-authenticate: Bearer resource_metadata="https://api.popnow.ai/.well-known/oauth-protected-resource/mcp", scope="generate read"

Step 2: it follows resource_metadata from that header to find out who issues tokens:

curl -s https://api.popnow.ai/.well-known/oauth-protected-resource/mcp

{
  "resource": "https://api.popnow.ai/mcp",
  "authorization_servers": ["https://api.popnow.ai"],
  "scopes_supported": ["generate", "read"],
  "bearer_methods_supported": ["header"]
}

Step 3: it reads the authorization server metadata:

curl -s https://api.popnow.ai/.well-known/oauth-authorization-server

The parts that matter: registration_endpoint (so the client can register itself, RFC 7591 dynamic client registration), code_challenge_methods_supported: ["S256"] (PKCE is required) and client_id_metadata_document_supported: true.

Step 4: the client registers, opens the authorize page with a PKCE challenge, and swaps the code for a token. From then on every MCP request carries Authorization: Bearer ....

That's why you never paste a key: the client does all four steps on its own. If a client claims it "can't connect", check which step fails. A missing www-authenticate header or a metadata URL that 404s is the usual culprit when you build your own server.

The two scopes are worth copying in your own servers: read (balance, history, model list) and generate (spend money). A connection approved without generate can look around but can't charge you.

3. First generation

Ask in plain words:

Make a 16:9 picture of a paper boat on a rainy window sill, soft morning light.

The agent calls create_image. Images return inline as a preview plus a download link, and every result also gets a permanent popnow:// link you can feed to the next tool:

Now turn that picture into a 5-second video with a slow push-in.

That's create_video with image_url set to the popnow:// link from the previous step. No downloading and re-uploading.

Useful read-only tools while you explore:

Tool	Use
`list_models`	Every image, video and audio model with its price (`category`: `image`, `video`, `audio`, `effects`)
`check_balance`	Credits left, and how many are held for running jobs
`list_my_creations`	Recent results with links
`get_job`	Collect a result that's still rendering

4. The two patterns that make paid tools safe for agents

Giving an autonomous agent a tool that spends money is the part people worry about. Two patterns handle it, and they're worth stealing for any MCP server that costs money.

Quote first, confirm above a threshold

Every generation tool takes an optional max_credits. Small jobs (up to 300 credits, i.e. $0.30) start right away. Anything bigger doesn't start: the tool answers with the price and your balance instead.

You:        Make a 9:16 video of a vintage car on a coast road at golden hour, 10 seconds.
Assistant:  (create_video → "Needs confirmation: costs 370 credits, balance 8450")
            That's 370 credits. Go ahead?
You:        Yes.
Assistant:  (create_video again with max_credits: 370 → job_id)

The confirmation is enforced by the server, not by the model being polite. If the price moved between the quote and the retry, nothing is charged and you get the new price. Failed jobs are refunded automatically.

Async jobs instead of long-held requests

Most videos take one to three minutes, much longer than you want an HTTP request to hang. The tool waits up to about 40 seconds; if the result isn't ready it returns a job_id, and the agent calls get_job (which can wait up to 50 seconds per call) until it's done.

One more detail that saves money: identical calls from the same account within ten seconds become one job, so an agent that retries after a timeout doesn't pay twice.

5. A real workflow: landing page plus hero video

Here's the prompt I use in Claude Code when scaffolding a marketing page:

Build a single-page landing page for "Driftwood", a note-taking app, in Next.js.
For the hero:
1. Use PopNow create_image to make a 16:9 still of a calm desk by a window, notebook open, morning light.
2. Turn it into a 5-second looping video with create_video (slow push-in, no text).
3. Download both into public/hero/ and use the image as the <video> poster.
4. Make a 30-second calm instrumental with create_music for the demo page and save it to public/audio/.
Show me the price before anything over 300 credits.

What to expect on the default models:

create_image: about 48 credits, returned inline
create_video with the popnow:// link from step 1: about 185 credits for 5 seconds, returns a job_id that the agent polls with get_job
create_music with instrumental: true: about 72 credits
The agent writes the files into public/ and wires up a <video autoplay muted loop playsinline poster=...> hero

Total: about 305 credits, roughly $0.31, without leaving the editor. Each step is under the 300-credit threshold, so nothing pauses for confirmation unless you ask for a longer or higher-resolution clip.

Tip: tell the agent which model to use when it matters ("use Seedance 2.5 for the video", "use Nano Banana for the still"). Every generation tool takes a model id from list_models.

6. What it costs, compared with going direct

The same model costs different amounts on different platforms. Here's one model at one setting, from the AI Video & Image Price Index (November 2026, public self-serve list prices, every row links to its source):

Seedance 2.5, text-to-video, 720p with audio, one 5-second clip

Platform	Price
PopNow (pay-as-you-go)	$1.39
Runway API	$1.50
Higgsfield API	$2.31
fal	$2.37

Prices change monthly; the index page has the full table, plus a CSV and JSON under CC BY 4.0 if you want to build your own comparison. PopNow credits are $0.001 each with no subscription; bigger packs add bonus credits.

Troubleshooting

Symptom	Fix
"Please connect your PopNow account first."	The tool ran before sign-in finished. Reconnect from `/mcp` (Claude Code) or the client's MCP settings
"This connection wasn't given permission to do that."	You approved without the `generate` scope. Disconnect, reconnect, press Allow
`405 Method Not Allowed`	The server is stateless: `POST` only. Any MCP client does this for you; only hand-rolled clients hit it
Cline connects but no tools work	Add `"type": "streamableHttp"`, otherwise Cline falls back to legacy SSE
"Too many creations at once"	More than 20 new jobs in a minute. Nothing was charged; wait the seconds in the message

Wrap-up

Remote MCP + OAuth means no keys in dotfiles and no local process to keep alive.
For any tool that spends money, put the confirmation in the server (quote, threshold, max_credits), not in the prompt.
Return job ids for anything slow, and de-duplicate retries.

Setup docs for every client: popnow.ai/mcp. Source for the configs: github.com/popnow-ai/popnow-mcp. If you build something with it, I'd like to see it in the comments.

What AI video and image generation really costs: same model on PopNow, Higgsfield, Runway and fal

PopNow — Wed, 04 Nov 2026 12:57:51 +0000

If you generate AI video regularly, the bill adds up fast, and the same model can cost very different amounts depending on where you run it. I checked the public prices for the same models at the same settings on four platforms: Higgsfield, Runway and fal, which many creators and developers use, and PopNow.

Disclosure up front: I work on PopNow, so read the numbers with that in mind. Every competitor price below comes from that platform's own public pricing page, and you can check each one yourself.

How the comparison works

One row is one generation: a 5-second clip for video models, one image for image models, same model, same resolution, same audio setting.
Only public, self-serve prices count. Runway and fal use their public API prices. For Higgsfield I take the higher of its API list price and its cheapest monthly plan that includes the model.
PopNow is priced with its biggest-bonus credit pack: the Pro pack, $100 for 112,000 credits, which includes 12,000 bonus credits.
Prices were checked on October 31, 2026. They change often, so confirm on each site before you buy.

Video: one 5-second clip

Model · setting	PopNow	Higgsfield	Runway	fal	Saving up to
MiniMax H3 (Hailuo) 2K	$0.26	$0.65	$0.75	$0.65	65%
MiniMax H3 768p	$0.17	—	$0.50	$0.30	67%
Seedance 2.0 Mini 480p	$0.11	—	$0.35	$0.36	69%
Seedance 2.0 Fast 720p	$0.43	$0.59	$1.20	$1.21	64%
Seedance 2.0 720p	$0.71	$1.51	$1.50	$1.52	53%
Seedance 2.0 1080p	$1.74	$3.40	$2.00	$3.41	49%
Seedance 2.5 720p	$1.24	$2.31	$1.50	$2.36	47%
Seedance 2.5 1080p	$3.05	$5.69	$3.40	$5.82	47%
Kling 3.0 1080p	$0.60	$0.84	$0.85	$0.84	29%

"—" means the platform does not offer that model or setting.

What stands out:

MiniMax H3 has the widest gap: a 2K five-second clip is $0.26 on PopNow and $0.65 or more elsewhere, so the same budget buys about 2.5 times as many clips.
Seedance 2.0 costs about $1.50 per 720p clip on the other three platforms; PopNow is under half that. Seedance 2.5 is over 40% below Higgsfield and fal.
Not every model is half price. Runway is relatively close on Seedance 2.5 (10 to 20% apart) and Kling 3.0 is 29% apart, so check the models you actually use.

Images: one image

Model · setting	PopNow	Higgsfield	Runway	fal	Saving up to
Nano Banana 2 · 1K	$0.048	$0.098	$0.070	$0.080	51%
Nano Banana Pro · 4K	$0.17	$0.20	$0.40	—	57%
Seedream 5.0 Pro · 1K	$0.032	—	$0.050	$0.068	52%
Seedream 5.0 Pro · 2K	$0.064	—	$0.090	$0.14	52%
GPT Image 2.5 · 4K medium	$0.032	—	$0.050	—	35%

A few cents per image sounds trivial until you batch hundreds of product shots or thumbnails.

A monthly example

Say you make 30 Seedance 2.0 720p clips (5 seconds each) and 300 Nano Banana 2 images at 1K every month:

fal: 30 × $1.52 + 300 × $0.080 = $69.60 a month
Higgsfield: 30 × $1.51 + 300 × $0.098 = $74.70 a month
PopNow: 30 × $0.71 + 300 × $0.048 = $35.70 a month

That is roughly $400 a year compared with fal. PopNow also sells one-time credit packs with no subscription, and credits do not expire, so a quiet month costs nothing.

Price protection

PopNow calls itself the first AI platform with price protection: if you find the same generation cheaper on Higgsfield, Runway or fal, it pays you twice the difference. The terms are specific, and worth reading before you count on it:

Only those three platforms, and only their standard public self-serve prices. Promotions, coupon codes, subscription bonus credits and enterprise rates do not count.
Same model, same version and same settings (resolution, duration, audio).
Claim within 7 days with your task ID, the other platform's pricing page and a dated snapshot. Every claim is checked by a person.
Paid as bonus credits (or API balance for API generations) valid for 90 days, up to $20 a month and no more than 10% of what you paid that month. Only successful generations paid with purchased credits count.

Summary

Same model, same setting: up to 69% less on PopNow in this snapshot. The biggest gaps are on MiniMax H3 and Seedance 2.0, often half or more.
Seedance 2.5 and Kling 3.0 users save less; check your own tier.
The live table with every source link is at popnow.ai/compare, and the data is on Hugging Face as popnow/ai-model-prices if you want to run your own numbers.

Disclosure: I work on PopNow. Competitor prices are their own published prices; please verify them yourself.

Nano Banana 2.1 vs GPT Image 2.5 vs Seedream 5.0: one prompt, first try, four tests

PopNow — Wed, 04 Nov 2026 12:57:35 +0000

Three of the most talked-about image models shipped new versions this autumn: Google's Nano Banana 2.1, OpenAI's GPT Image 2.5 and ByteDance's Seedream 5.0. Most comparisons use English prompts and pick the best of several tries. I wanted something closer to everyday use, so I ran the same prompt once on each model and kept the first result, including two prompts that ask for Chinese text inside the image, which is where models still slip.

Setup

Same prompt for all three, portrait 3:4, 1K resolution, one generation each, no retries, no editing.
All three run with the same parameters on one platform, so default settings do not differ between sites.
Price per image at these settings: Nano Banana 2.1 about $0.048, GPT Image 2.5 (Sunburst, high quality) about $0.031, Seedream 5.0 Pro about $0.036.

In every comparison image, left to right: Nano Banana 2.1 | GPT Image 2.5 | Seedream 5.0.

Test 1: a poster with exact Chinese text

Prompt (translated): a portrait grand-opening poster for a bubble tea shop, warm illustration style, big title "开业大吉" (Grand Opening), a line "全场第二杯半价" (second cup half price) and a small footer "11月8日 · 人民路88号" (Nov 8 · 88 Renmin Road), clean layout, no typos.

Nano Banana 2.1 produced a lovely poster but translated every line into English. It ignored the instruction.
GPT Image 2.5 rendered all three Chinese lines correctly and the layout looks like a real commercial poster.
Seedream 5.0 also got every character right, in a softer, cuter style, and invented a "Dear Tea" cup design.

Test 2: a hand-drawn infographic with Chinese labels

Prompt (translated): a hand-drawn infographic titled "手冲咖啡四步法" (four steps to pour-over coffee), four steps left to right with sketches: grind (medium-fine), wet the filter, bloom 30 seconds, pour in stages, a short Chinese caption under each, beige paper background.

Nano Banana 2.1 went bilingual with English first, in a 2×2 grid instead of left to right.
GPT Image 2.5 gave the cleanest result: four numbered steps in a row, correct and readable Chinese captions.
Seedream 5.0 has the strongest hand-drawn feel with correct titles and steps; one small caption has a redundant annotation.

Test 3: an e-commerce product shot

Prompt: an amber glass perfume bottle on wet dark slate after rain, a few damp green leaves, soft side light, shallow depth of field, premium commercial photography.

All three are usable. Nano Banana 2.1 looks the most like a real photo (and made up a label). GPT Image 2.5 looks the most "luxury ad". Seedream 5.0 is clean and minimal. For your own product, use image-to-image with a real photo instead of asking a model to invent the bottle.

Test 4: imagination

Prompt: a corgi in a white spacesuit sitting on the Moon eating Sichuan hot pot, red chili broth steaming, blue Earth in the distance, cinematic light.

Nano Banana 2.1: good composition, but the corgi is small and took its helmet off on the Moon.
GPT Image 2.5: the most striking close-up, though it drew a NASA logo on the suit, which matters if you use it commercially.
Seedream 5.0: helmet on, the richest details, and the best grasp of "Sichuan hot pot".

Takeaways

	Nano Banana 2.1	GPT Image 2.5	Seedream 5.0
Non-English text	Weak, tends to switch to English	Strong	Strong
Photorealism	Strong	Strong	Good
Following instructions	Medium	Strong	Strong
Price per 1K image	~$0.048	~$0.031	~$0.036

Posters, cards and diagrams with exact text, especially non-English: start with GPT Image 2.5, then Seedream 5.0.
Photoreal products and portraits: Nano Banana 2.1 is still excellent; just don't rely on it for Chinese text.
Scenes with Chinese cultural context: Seedream 5.0 understood them best.

No model won everything. At two or three cents an image, running one prompt on all three and picking the best is faster than rewriting the prompt again and again. I ran these on PopNow, where the three models sit behind one account and the price shows before each run.

All images are first generations with no edits, and the prompts are above if you want to reproduce them.

Disclosure: I work on PopNow.

A URL is not an asset record: keep a manifest beside generated media

PopNow — Wed, 28 Oct 2026 12:19:44 +0000

A media-generation prototype can get surprisingly far with an array of output URLs. Then someone asks which reference image produced a clip, whether two results used the same settings, or why a saved link no longer opens. The array cannot answer those questions.

A useful next step is a small asset manifest. Give the result an application-owned identity, and store its recipe separately from its current delivery address.

This article proposes an application data model. The TypeScript is illustrative, not a provider SDK or a description of an existing production schema. This tutorial was drafted by an AI agent and reviewed for accuracy by PopNow Team before publication. The team confirmed that it reflects knowledge they are familiar with. No remote generation or benchmark was run for it.

Separate identity, recipe, and delivery

These three concepts change for different reasons:

Identity: the asset your application and its users refer to.
Recipe: the inputs and settings that explain one generation attempt.
Delivery: where an output can currently be obtained.

A refreshed signed URL does not necessarily mean a new creative result. A changed prompt does mean a new recipe. The application should not infer either fact from string equality between URLs.

Here is one possible TypeScript model:

type Recipe = Readonly<{
  id: string;
  modelRef: string;
  promptRef: string;
  referenceAssetIds: readonly string[];
  settings: Readonly<Record<string, string | number | boolean>>;
}>;

type Delivery =
  | {
      kind: "remote";
      url: string;
      observedAt: string;
      expiresAt?: string;
    }
  | {
      kind: "stored";
      objectKey: string;
      contentType: string;
      checksum?: string;
    };

type MediaAsset = {
  id: string;
  projectId: string;
  recipeId: string;
  providerTaskRef?: string;
  createdAt: string;
  delivery: Delivery;
};

These names belong to the application. An adapter translates a provider's actual response into this representation; the type definitions do not imply that any particular API returns these fields.

promptRef is a reference to an access-controlled record, not a reason to copy prompts into analytics events. Similarly, a storage object key belongs in the manifest; public access can be decided separately when someone asks to view the asset.

Snapshot the recipe before starting work

Suppose a user selects a reference image and adjusts the duration. Save that approved configuration as a recipe before submitting the generation request. Associate the returned task reference with that attempt when it becomes available.

Do not let a later edit mutate the historical recipe. If a user revises the prompt, create another recipe and associate the next attempt with it. Otherwise an old clip will appear to have been generated from today's settings.

The Readonly types above help express intent to TypeScript callers. They do not freeze objects at runtime or enforce database immutability. A production implementation still needs its own write rules, versioning strategy, and authorization checks.

Keep delivery updates narrow

When a provider supplies a replacement delivery link for an existing result, the adapter may update the delivery information associated with that asset. It should not overwrite the recipe or invent a new creative revision merely because the address changed.

Conversely, do not assume that any two URLs pointing to apparently similar images identify the same output. Deduplication needs evidence appropriate to the application. A provider's stable output identifier can be useful; a checksum of downloaded bytes answers a narrower question about byte identity.

An expiry field should be filled only when its meaning is documented or otherwise known. An absent expiresAt means "unknown in this record," not "available forever." Decide what the UI should do when a remote link is unavailable, instead of hiding that state behind a permanent thumbnail.

If your application copies an output into its own storage, record that completed storage operation separately. A task reaching a completed state is not proof that your archive copy succeeded.

Build comparisons from the manifest

A comparison view can now show a thumbnail with its model reference, recipe, and selected settings. It can keep a selected result tied to the exact attempt a reviewer approved.

For a fictional product-photo comparison, a reviewer might record:

asset-101 -> recipe-31 -> keep
asset-102 -> recipe-32 -> revise: label changed
asset-103 -> recipe-33 -> reject: wrong object shape

The review belongs to the asset and its recorded recipe. Replacing a thumbnail in a grid should not silently move that decision to a different result.

This also makes exports clearer. A project can export selected assets together with a manifest that explains their provenance, without pretending that the manifest itself grants rights to the input references or generated content.

Check the boundaries with local fixtures

You do not need a paid generation call to exercise this data model. Construct fictional provider responses and check that:

Updating a delivery link preserves the asset and recipe identities.
A deliberate input revision creates a new recipe.
Unknown expiry remains unknown.
A failed archive copy does not mark the output as stored.
A project cannot resolve another project's private recipe through an asset reference.

These are suggested application tests, not claims that a remote service has passed them. The point is to make the relationships explicit enough that a test can describe the behavior you intend.

An asset manifest is a modest addition to a prototype. Its value is that "which result is this?", "how was it requested?", and "where can I retrieve it?" become separate questions with separate answers.

How to Generate AI Videos from Code with One API (Node.js + Python Examples)

PopNow — Wed, 21 Oct 2026 13:51:50 +0000

Generating an image from code is usually one request: you send a prompt and get a picture back a few seconds later. Video is different. A five-second clip can take minutes to render, so a single HTTP call that blocks until the file is ready is the wrong shape. What you need is a small job flow: submit the work, track it, collect the result.

This tutorial builds that flow end to end with plain fetch in Node.js and requests in Python. The examples use the PopNow API, which puts many video models (Wan, MiniMax, Kling, Seedance, Vidu and others) behind one request format, so switching models is a one-line change. The pattern itself — create a task, poll or receive a webhook, download before the link expires — carries over to most async generation APIs.

What you'll build

A script that:

Asks for the price of a clip before running it.
Creates a text-to-video task.
Polls until the task is finished.
Downloads the MP4 to disk.

After that we'll animate an image instead, switch to a second model, and look at what changes when you move from a script to production.

Prerequisites

Node.js 18+ or Python 3 with requests.
A PopNow account and an API key. Keys are created in the API console and start with sk-popnow-. The API spends the same credits as the website; there is no separate API plan and no subscription. You buy a one-time credit pack (packs start at $9) and pay as you go. One credit is $0.001.

export POPNOW_API_KEY="sk-popnow-..."

Keep the key on your server. It spends real credits, so it should never end up in a browser bundle or a mobile app.

The request shape

Every generation — image, video or audio — goes through the same endpoint:

POST https://api.popnow.ai/api/v1/jobs/createTask
Authorization: Bearer $POPNOW_API_KEY
Idempotency-Key: <unique id for this job>

The body has two required fields:

{
  "model": "alibaba/wan-3.0/text-to-video",
  "input": {
    "prompt": "A paper boat drifts down a rain-soaked street at dusk, neon signs reflecting in the water, slow tracking shot at ground level",
    "resolution": "480p",
    "duration_seconds": 5,
    "aspect_ratio": "16:9"
  }
}

model picks both the model and the job: text-to-video, image-to-video, video-extend and so on.
input is validated against that model's own schema. Unknown fields are rejected, so a typo like duraton_seconds fails immediately instead of being silently ignored.
Idempotency-Key makes retries safe. If a request times out and you resend it with the same key, you get the original task back instead of a second charge.

Every JSON response uses the same envelope: { "code", "msg", "data", "request_id" }. Note that code is a business code, not the HTTP status. 200 means success; anything else is an error. Branch on code, never on the wording of msg, and log request_id so you can quote it if you need support.

Step 1: Ask for the price first

Video is priced per second of output, and the rate depends on resolution. For Wan 3.0 text-to-video it is 45 credits per second at 480p, 90 at 720p and 180 at 1080p. Instead of hard-coding a price table, ask the API. POST /jobs/quote takes exactly the body you would send to createTask and returns the price without creating a task or holding any credits:

curl -X POST "https://api.popnow.ai/api/v1/jobs/quote" \
  -H "Authorization: Bearer $POPNOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"alibaba/wan-3.0/text-to-video","input":{"prompt":"A paper boat drifts down a rain-soaked street","resolution":"480p","duration_seconds":5}}'

The response carries maxCredits (the most the request can cost, which is the amount that will be held from your balance) and expectedCredits (what it usually costs). Five seconds at 480p is 5 × 45 = 225 credits, or $0.225.

If you show that price to an end user and want it to stick, pass the quoteId and the maxCredits you showed (as expectedCredits) in createTask within five minutes. If anything changed in between, the API answers 40901 and holds nothing, so you can quote again.

Step 2: Create, poll and download in Node.js

Save this as video.mjs and run it with node video.mjs. It uses only built-in modules.

// video.mjs: text-to-video, end to end
import { randomUUID } from 'node:crypto';
import { writeFile } from 'node:fs/promises';

const API = 'https://api.popnow.ai/api/v1';
const headers = {
  Authorization: `Bearer ${process.env.POPNOW_API_KEY}`,
  'Content-Type': 'application/json',
};

const job = {
  model: 'alibaba/wan-3.0/text-to-video',
  input: {
    prompt:
      'A paper boat drifts down a rain-soaked street at dusk, neon signs ' +
      'reflecting in the water, slow tracking shot at ground level',
    resolution: '480p',
    duration_seconds: 5,
    aspect_ratio: '16:9',
  },
};

// Small helper: unwrap the { code, msg, data, request_id } envelope.
async function call(path, init = {}) {
  const res = await fetch(`${API}${path}`, {
    ...init,
    headers: { ...headers, ...init.headers },
  });
  const body = await res.json();
  if (body.code !== 200) {
    throw new Error(`${body.code} ${body.msg} (request ${body.request_id})`);
  }
  return body.data;
}

// 1. Price check.
const quote = await call('/jobs/quote', { method: 'POST', body: JSON.stringify(job) });
console.log(`at most ${quote.maxCredits} credits ($${quote.maxCharge})`);

// 2. Create the task. In a real app, store this key with your own job record
//    so a retry after a timeout returns the same task.
const created = await call('/jobs/createTask', {
  method: 'POST',
  headers: { 'Idempotency-Key': randomUUID() },
  body: JSON.stringify(job),
});
console.log(`task ${created.taskId} is ${created.state}`);

// 3. Poll until the state is final. Unknown states count as "not final yet".
const FINAL = new Set(['succeeded', 'failed', 'expired']);
let task;
do {
  await new Promise((r) => setTimeout(r, 5000));
  task = await call(`/jobs/recordInfo?taskId=${encodeURIComponent(created.taskId)}`);
  process.stdout.write(`\r${task.state}...   `);
} while (!FINAL.has(task.state));
console.log();

if (task.state !== 'succeeded') {
  throw new Error(`task ${task.state}: ${task.errorCode ?? ''} ${task.errorMessage ?? ''}`);
}

// 4. Download right away: the signed link is short-lived.
const asset = task.output.assets[0];
const file = await fetch(asset.url);
await writeFile('clip.mp4', Buffer.from(await file.arrayBuffer()));
console.log(`saved clip.mp4 (${asset.durationSeconds}s, ${asset.width}x${asset.height}), charged ${task.credits} credits`);

A few things worth knowing about what just happened:

createTask returns HTTP 202, not the video. 202 means accepted. The response has a taskId, state: "queued" and estimatedCredits, which is the hold: the most this task can cost.
You pay for what was used. When the task succeeds, you are charged the actual amount, rounded up to whole credits and never more than the hold; the rest goes back to your balance. When a task fails or expires, the hold is released.
States. A task moves from queued to running and ends as succeeded, failed or expired. On failure, branch on errorCode and show errorMessage.
Signed links expire. output.assets[0].url works for about 20 minutes and needs no API key. The file itself is still there afterwards: read the task again with recordInfo to get a fresh link. Store the taskId, not the URL.

For images you can skip the polling loop: add ?wait=60 to createTask and the connection stays open for up to 60 seconds, so a quick image comes back in the same response. Video almost always takes longer than that, which is why this script polls.

The same flow in Python

# video.py: pip install requests, then python video.py
import os
import time
import uuid

import requests

API = "https://api.popnow.ai/api/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['POPNOW_API_KEY']}"}
FINAL = {"succeeded", "failed", "expired"}


def call(method, path, **kwargs):
    """Send a request and unwrap the {code, msg, data, request_id} envelope."""
    headers = {**HEADERS, **kwargs.pop("headers", {})}
    body = requests.request(method, f"{API}{path}", headers=headers, timeout=30, **kwargs).json()
    if body["code"] != 200:
        raise RuntimeError(f'{body["code"]} {body["msg"]} (request {body.get("request_id")})')
    return body["data"]


job = {
    "model": "alibaba/wan-3.0/text-to-video",
    "input": {
        "prompt": "A paper boat drifts down a rain-soaked street at dusk, neon signs "
                  "reflecting in the water, slow tracking shot at ground level",
        "resolution": "480p",
        "duration_seconds": 5,
        "aspect_ratio": "16:9",
    },
}

quote = call("POST", "/jobs/quote", json=job)
print(f'at most {quote["maxCredits"]} credits (${quote["maxCharge"]})')

created = call("POST", "/jobs/createTask", json=job,
               headers={"Idempotency-Key": str(uuid.uuid4())})
print("task", created["taskId"], "is", created["state"])

while True:
    time.sleep(5)
    task = call("GET", "/jobs/recordInfo", params={"taskId": created["taskId"]})
    if task["state"] in FINAL:
        break

if task["state"] != "succeeded":
    raise SystemExit(f'task {task["state"]}: {task.get("errorCode")} {task.get("errorMessage")}')

asset = task["output"]["assets"][0]
with requests.get(asset["url"], stream=True, timeout=120) as r:
    r.raise_for_status()
    with open("clip.mp4", "wb") as f:
        for chunk in r.iter_content(chunk_size=1 << 20):
            f.write(chunk)
print("saved clip.mp4, charged", task["credits"], "credits")

Animate an image instead

Image-to-video is the same code with a different model and input:

const job = {
  model: 'alibaba/wan-3.0/image-to-video',
  input: {
    image_url: 'https://media.popnow.ai/movie/lighthouse.webp',
    prompt: 'Waves roll in slowly, clouds drift, the camera pushes gently toward the lighthouse',
    resolution: '480p',
    duration_seconds: 5,
  },
};

image_url is the opening frame. Many image-to-video models also accept last_image_url: the clip then ends exactly on that image. Use the same picture for both and you get a smooth loop, which is handy for product shots and background videos.

Switch models with one line

Because every model sits behind the same endpoint, trying another one is a matter of changing model. Here is MiniMax H3's text-to-video:

const job = {
  model: 'minimax/h3/text-to-video',
  input: {
    prompt: 'A paper boat drifts down a rain-soaked street at dusk, slow tracking shot at ground level',
    resolution: '768p',
    duration_seconds: 5,
  },
};

Notice that the resolution values are different: H3 takes 768p or 2k and 5 to 15 seconds, while Wan 3.0 takes 480p, 720p or 1080p and up to 30 seconds. That is where schema validation pays off. If you swap the model and forget to change 480p, the request is rejected up front instead of running with a setting you didn't ask for. H3 costs 37 credits per second at 768p, so this clip is 185 credits.

To see every model ID with its price from code, call GET /api/v1/models.

Going to production: webhooks instead of polling

Polling every few seconds is fine for a script. In an app with many users, let the API call you instead. Add a callBackUrl (a public HTTPS URL) to the createTask body, and the finished task is POSTed to it.

Deliveries are signed with your account's webhook secret, which you generate in the API console:

signature = base64( HMAC-SHA256( secret, "<taskId>.<timestamp>.<sha256_hex(raw_body)>" ) )

The signature arrives in X-Webhook-Signature and the timestamp in X-Webhook-Timestamp. Hash the raw bytes you received, not a re-serialized object. Here is a compact Express receiver:

import crypto from 'node:crypto';
import express from 'express';

const app = express();
const SECRET = process.env.POPNOW_WEBHOOK_SECRET;

app.post('/hooks/popnow', express.raw({ type: 'application/json', limit: '10mb' }), (req, res) => {
  const ts = Number(req.headers['x-webhook-timestamp']);
  const sig = String(req.headers['x-webhook-signature'] ?? '');
  if (!Number.isInteger(ts) || Math.abs(Date.now() / 1000 - ts) > 300) return res.status(401).end();

  let event;
  try { event = JSON.parse(req.body.toString('utf8')); } catch { return res.status(400).end(); }
  const digest = crypto.createHash('sha256').update(req.body).digest('hex');
  const expected = crypto.createHmac('sha256', SECRET)
    .update(`${event.data?.taskId}.${ts}.${digest}`).digest('base64');
  const ok = expected.length === sig.length &&
    crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(sig));
  if (!ok) return res.status(401).end();

  res.status(200).end();                   // acknowledge first...
  console.log(event.data.taskId, event.data.state); // ...then queue the real work
});

app.listen(3000);

A few rules make webhook handlers robust:

Answer fast. Any 2xx within 15 seconds counts as received. Download and transcode in a background job.
Expect duplicates. Failed deliveries are retried, so the same task can arrive twice. request_id in the body is the delivery ID and stays the same across retries; store it with a unique index and ignore repeats.
The webhook says "delivered", not "succeeded". code is 200 even for a failed task. Read data.state.
Reconcile. Once a day, list recent tasks with GET /api/v1/jobs and read any whose webhook you never received.

And a few that apply whether you poll or not:

Derive the Idempotency-Key from your own job ID, so a retry can never create a second task.
Copy finished files into your own storage. Outputs are kept for a limited time; the task record says when in retention.outputsExpireAt.
Tune prompts at the lowest resolution and a short duration, then raise both for the final render.

A note on prompts

Video models reward prompts that describe motion, not just the scene. "A beautiful lighthouse" gives the model nothing to do. "Waves roll in slowly, clouds drift, the camera pushes gently toward the lighthouse" tells it what moves, how fast, and what the camera does. With image-to-video this matters even more: the picture already shows what things look like, so spend your words on what changes.

Wrapping up

The whole integration comes down to three calls — jobs/quote, jobs/createTask and jobs/recordInfo — plus a webhook once you go to production. Since the request shape is the same for every model, you can write this code once and compare models by changing a single string.

The full reference, including uploads for your own images, error codes and per-model parameters, is in the PopNow API docs.