DEV Community: useapi.net

NotebookLM API Options in 2026: Google Enterprise API, Free Libraries or a Hosted API

useapi.net — Fri, 16 Oct 2026 21:18:44 +0000

Does NotebookLM have an API?

Not for regular Google accounts. Google renamed NotebookLM to Gemini Notebook in July 2026, and its only official API is the Gemini Notebook Enterprise API: a Preview API for Enterprise licenses in a Google Cloud project, which manages notebooks and sources and creates Audio Overviews.

If you want to automate NotebookLM on an ordinary free or paid Google account, there are three kinds of options:

Google's Enterprise API, if your organisation buys Enterprise licenses.
Free open-source libraries and local MCP servers, such as notebooklm-py and gemini-notebook-mcp-cli, which you install and run on your own machine.
A hosted API, such as the useapi.net NotebookLM API (Gemini Notebook API), which runs on our servers with your own Google account, over REST and as a hosted MCP server.

This page is written by the useapi.net maintainers and compares what each option offers from its own documentation.

Compared

	useapi.net	notebooklm-py	gemini-notebook-mcp-cli	Google Enterprise API
Hosted, nothing to install or run locally	✅	❌	❌	✅
Hosted MCP server for Claude Code, Cursor, VS Code	✅	❌ (local only)	❌ (local only)	❌
Works on free and paid consumer Google accounts	✅	✅	✅	❌
Sign-in without copying cookies; session kept fresh for you	✅	❌	❌	✅
REST API from any language	✅	❌	❌	✅
Webhook when a job finishes	✅	❌	❌	❌
Automatic load balancing across Google accounts	✅	❌	❌	❌
Ready-to-import n8n templates	✅	❌	❌	❌
Price	$15/month, every useapi.net API	Free	Free	Enterprise licenses

From each project's own documentation on October 16, 2026: notebooklm-py v0.8.5, gemini-notebook-mcp-cli v0.15.5, Gemini Notebook Enterprise API (Preview). useapi.net is a third-party API and is not affiliated with Google.

Why useapi.net instead of a free library

useapi.net is a third-party API and is not affiliated with Google.

Nothing to run on your machine. The API is hosted, so jobs keep running when your laptop is off: no Chromium download, no local server, no tunnel and no browser left open.
Sign in once, we keep you signed in. The guided browser setup connects your Google account once, and we keep the session fresh, with no cookies to copy or refresh. If Google ever signs it out, you get an email with a one-minute re-add link.
A hosted MCP server, 56 tools. Add it to Claude Code, Cursor or VS Code with one line. Nothing to install, and every notebook, source, chat and Studio output is available to your AI assistant.
Plain REST from any language. Call it from Node.js, Python, bash, n8n, Make or a cron job with an API token. A Postman collection and an LLM-friendly spec cover every endpoint.
Jobs tracked for you, with webhooks. Every podcast, video, slide deck and research run is a server-side job. Poll it, or pass replyUrl and get the finished result posted to your endpoint.
Several Google accounts, balanced automatically. Connect 3 accounts per subscription, up to 100; each new job goes to one that is healthy, has a free slot and still has usage left.
Links in, podcast out. Send URLs or text to one endpoint and get an Audio Overview, Video Overview, slide deck or quiz back, with no notebook setup.
Ready-made n8n workflows and an agent skill, on your free or paid Google plan, for a flat $15/month that covers every useapi.net API.

What the useapi.net NotebookLM API covers

Everything you do in NotebookLM, from code:

Notebooks and sources. Create, copy and share notebooks and group them in collections. Add web pages, YouTube videos, pasted text, uploaded files (PDF, Word, PowerPoint, EPUB, audio, video), Google Drive files and ebooks from your Google Play Books library.
Chat with citations. Ask questions grounded in your sources, with numbered citations and follow-up conversations.
Research. Discover sources and run Deep Research, then import the sources and the report.
Every Studio output. Audio Overviews (deep dive, brief, critique, debate), Video Overviews (including short and cinematic), slide decks, infographics, reports, data tables, quizzes, flashcards and mind maps, with revise, retry, copy and export.
Usage you can see. Each account's live usage in Google's 5-hour and weekly windows.

The full list is in the API reference.

How to start

Get a useapi.net API token.
Connect a Google account once with the guided NotebookLM setup. The free Google plan works.
Turn a web page into a podcast with one call:

curl -X POST https://api.useapi.net/v1/gemini-notebook/artifacts \
  -H "Authorization: Bearer $USEAPI_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type": "audio", "urls": ["https://en.wikipedia.org/wiki/Apollo_11"]}'

Or add the MCP server to Claude Code with one line:

claude mcp add --transport http useapi-gemini-notebook https://api.useapi.net/v1/gemini-notebook/mcp --header "Authorization: Bearer YOUR_API_TOKEN"

Step-by-step tutorials: Deep Research, chat and Audio Overviews with curl, a real podcast example and RSS feeds to podcasts with n8n. Runnable code: useapi/notebooklm-api.

Start using the API

A single $15/month subscription covers every API on useapi.net — one token, all services. You connect up to 3 of your own provider accounts per service, and useapi.net handles the REST API, load balancing, and polling.

Subscribe — $15/month

Pricing, crypto payment, and volume options — full refund within the first 14 days if you have fewer than 50 successful generations.

Frequently asked questions

Is there a free NotebookLM API? Google offers no free API for regular accounts. Free open-source libraries exist and run on your own machine. The useapi.net API is $15/month, works on the free Google plan, and has a full refund within 14 days if you made fewer than 50 successful generations.

Is there a NotebookLM API key? Not from Google for regular accounts. With useapi.net you use a useapi.net API token and connect your Google account once.

Can I use NotebookLM from Python? Yes. The useapi.net API is plain REST, so any HTTP client works. The examples repository has Node.js, Python and bash scripts and a Colab notebook.

Is there a NotebookLM MCP server? Yes. The hosted useapi.net NotebookLM MCP server has 56 tools and is listed in the official MCP Registry as net.useapi/gemini-notebook. You add it to Claude Code, Cursor or VS Code with one line, with nothing to install.

Do I have to copy cookies or keep a browser open? No. You sign in once through the guided setup, and we keep the session fresh. If Google ever signs the account out, you get an email with a link to re-add it.

How to Generate AI Images and Videos with the Muse API

useapi.net — Mon, 12 Oct 2026 06:14:53 +0000

Introduction

The useapi.net Muse API drives Muse, Meta's personal AI agent, from code: one POST makes an image or a 10-second video with spoken dialogue, and every file it makes is an asset id the next job can take as an input.

The API runs on your own Muse account, and the free plan works. This walkthrough takes three ordinary photos, a vintage BMW motorcycle, a red-haired rider and the beach below the Golden Gate Bridge, and turns them into one picture of her riding that motorcycle through the surf. The picture then becomes a video in which she shouts a line, and in a third job a different woman, taken from a fourth photo, replaces her in that video while the ride stays the same. Along the way it makes images from text, and it restores and colorizes a hundred-year-old portrait that then looks up and speaks. Every request below is the one that made the media on this page.

The rider from a photo, swapped into a clip Muse made from a still image (step 8).

What it cost

useapi.net is an API, not an image or video service of its own. Every call runs on a Muse account you add through Setup Muse, and uses that account's weekly Muse allowance. Muse reports it as a whole percent used, so a single image often shows no change. You pay useapi.net a flat $15/month for every API we offer, with no per-image or per-video charge.

What each step used on the free plan, taken from percentUsed before and after it, and how long each job took:

Step	Endpoint	Output	Allowance used	Time
Text to image, 9:16	POST /jobs/image	1152×2048	not measured	30 s
Text to image, exactly 16:9	POST /jobs/image	2048×1152	0%	21 s
Rider + motorcycle + beach	POST /jobs/image	2048×1152	0%	31 s
The ride as a video	POST /jobs/video	1280×720, 10 s	3%	88 s
Restore an old photo	POST /jobs/image	1344×1792	1%	34 s
The portrait speaks	POST /jobs/video	832×1104, 10 s	2%	68 s
Swap the rider	POST /jobs/video	1248×704, 10 s	3%	138 s

Uploads use no allowance. On the free plan a video used 2 to 3 percent of the week and an image 0 to 1 percent, so one free account makes roughly 30 to 50 videos a week, or several hundred images (step 9).

Before you start

You need a useapi.net API token and a Muse account added through Setup Muse. Before you add the account:

Finish Muse's onboarding at muse.ai, including Meta's age check, and create one image there.
The account must have email + password sign-in, because the API signs in with the email and password. A Meta account that signs in only with an emailed code has no password yet: create one in Meta Accounts Center (Password and security), then add the account here. Without a password the add is refused with 400.
Use the account only for the API, with no other automation tools on it. Opening it at muse.ai in a browser is fine.

Every call is also in the Postman collection.

Also in Chinese: 中文教程. The whole walkthrough is also on GitHub as one script, in Node.js and Python: images-videos/ in useapi/muse-api, plus an agent skill for Claude Code and Codex.

The steps use curl, jq and these variables and helpers:

export USEAPI_TOKEN="user:12345-..."
export EMAIL="example@gmail.com"
export MUSE_PASSWORD="..."   # the Muse account password, used once in step 1
API=https://api.useapi.net/v1/muse
AUTH="Authorization: Bearer $USEAPI_TOKEN"
enc() { jq -rn --arg v "$1" '$v|@uri'; }
post() { curl -sS -X POST "$API/$1" -H "$AUTH" -H "Content-Type: application/json" -d "$2"; }
get() { curl -sS "$API/$1" -H "$AUTH"; }
upload() { curl -sS -X POST "$API/assets?email=$(enc "$EMAIL")" -H "$AUTH" -H "Content-Type: $2" --data-binary @"$1" | jq -r .assetId; }
download() { curl -sSf "$API/assets/$(enc "$1")" -H "$AUTH" -o "$2"; }

# run a job async: submit it, poll GET /jobs/{jobid} every 10 s, save the final job record to $1
run() {
  local job id
  job=$(post "$2" "$(jq '. + {async: true}' <<< "$3")")
  id=$(jq -r .jobid <<< "$job")
  while [ "$(jq -r .status <<< "$job")" = started ]; do
    sleep 10
    job=$(get "jobs/$(enc "$id")")
  done
  echo "$job" > "$1"
  jq '{status, error, text: .result.text, asset: .result.assets[0].assetId}' "$1"
}

Every generation runs as a job. Without async, a POST waits up to about 100 seconds and returns the finished job record, or 202 with the job still running. A video here took 68 to 138 seconds, so run sends every job with async: true and polls GET /jobs/jobid. If run prints any status other than completed, read its error before going on.

To be called back instead of polling, add replyUrl: "https://example.com/hooks/muse" (and optionally replyRef) to any body below. The API then sends one POST of the final job record, as JSON, to that URL.

Ids contain : and @, so enc URL-encodes them whenever they go into a URL path. All inputs of one job must live on the same Muse account, so the uploads pin email, and a job runs on the account that holds its inputs.

How it was built

1. Add the account

POST /accounts takes the Muse account's email and password. The API signs in once, keeps the 30-day session and renews it itself. Muse emails the account a login code at each sign-in. That email is only a notice, nothing needs to be entered.

post accounts "$(jq -n --arg email "$EMAIL" --arg password "$MUSE_PASSWORD" '{email: $email, password: $password}')" | jq '{health, maxJobs, quota}'

The answer shows health: "OK", maxJobs (2 by default) and the account's plan and usage, here tier: "HATCH_FREE", the free plan. If it answers 596 instead, Meta wants a security check: sign in once at muse.ai in a browser, complete it, and post the same email and password again.

2. Upload the photos

POST /assets takes the raw file as the body, up to 8.6 MB, and writes it into the account's Muse workspace. Nothing is stored at useapi.net. The answer's assetId is what a job takes as image_N.

BMW=$(upload bmw.jpeg image/jpeg)
RIDER=$(upload rider.jpeg image/jpeg)
BEACH=$(upload beach.jpeg image/jpeg)
OLD_PHOTO=$(upload old-photo.jpeg image/jpeg)
PINK=$(upload pink-hair.jpeg image/jpeg)
echo "$BMW"
# user:12345-email:6578616d706c6540676d61696c2e636f6d-image:7db53e7a1f0979cbab6ff46ec3f0a35b60e6ee579a0d738a9628cf46a0c7a0f5.jpg

image_1 — the motorcycle">

image_1 — the motorcycle

image_2 — the rider">

image_2 — the rider

image_3 — the beach">

image_3 — the beach

the old portrait
the second rider

The five inputs: the motorcycle, the rider, the beach, the old portrait and the second rider.

The asset id is built from the file's content, so uploading the same file to the same account again returns the same id and writes nothing.

3. Images from text

Muse has no aspect-ratio parameter: the prompt says it. A vertical portrait first:

run portrait.json jobs/image "$(jq -n '{prompt: "Vertical 9:16 full-body portrait photo: a confident young woman biker with long wavy fiery red hair, green eyes and freckles, in a worn black leather jacket, dark jeans and boots, standing in a rain-soaked neon alley at dusk, looking straight at the camera, cinematic lighting, photorealistic."}')"
download "$(jq -r '.result.assets[0].assetId' portrait.json)" portrait.webp

open in new tab

That came back at exactly 9:16, 1152×2048. A landscape version asked as Cinematic 16:9 landscape photo: … came back 1920×1280, which is 3:2. Writing the ratio as in exactly 16:9 aspect ratio fixed it:

run bmw-noir.json jobs/image "$(jq -n '{prompt: "In exactly 16:9 aspect ratio (landscape), a cinematic photo of a vintage 1920s black BMW motorcycle with white pinstripes, spoked wheels and a brown leather saddle, parked on wet cobblestones at night in San Francisco, the Golden Gate Bridge glowing through fog in the distance, neo-noir moonlight, reflections on the wet street, shot on 35mm film."}')"
download "$(jq -r '.result.assets[0].assetId' bmw-noir.json)" bmw-noir.webp

open in new tab

Muse answered "That 16:9 frame with the bridge ghosting through the fog is pure neo-noir. Enjoy." Its reply is in result.text.

4. Three photos into one picture

Up to 9 images go into one job as image_1..image_9, and the prompt names them. Here the motorcycle is image_1, the rider image_2 and the beach image_3. The prompt asks Muse to use the photographed beach as it is, so the Golden Gate Bridge stays where it was in the photo.

run beach-ride.json jobs/image "$(jq -n --arg bmw "$BMW" --arg rider "$RIDER" --arg beach "$BEACH" \
  '{image_1: $bmw, image_2: $rider, image_3: $beach,
  prompt: "In exactly 16:9 aspect ratio (landscape), a cinematic photo: the woman from image_2 (her face, long wavy red hair, light blue top and jeans) riding the exact vintage motorcycle from image_1 along the shoreline of the beach in image_3, the front wheel cutting through the shallow surf and throwing spray, bright afternoon sun, her hair streaming in the wind, photorealistic. Use the beach, rocks and Golden Gate Bridge from image_3 as the background exactly as photographed: same position, same orientation, not mirrored or redrawn. Keep her face and the motorcycle'\''s design exactly as in the images."}')"
BEACH_RIDE=$(jq -r '.result.assets[0].assetId' beach-ride.json)
download "$BEACH_RIDE" beach-ride.webp

open in new tab

31 seconds, and no visible change in the weekly allowance.

5. The picture as a video, no re-upload

BEACH_RIDE is the id of a file Muse made. It is already in the account's workspace, so it goes straight into the next job as image_1, with no download and no upload. Animate image_1 makes a clip that starts from the picture and keeps its shape, and the line in quotes is spoken.

run surf.json jobs/video "$(jq -n --arg img "$BEACH_RIDE" '{image_1: $img,
  prompt: "Animate image_1 into a cinematic video in exactly 16:9 aspect ratio (landscape): she rides the vintage motorcycle along the shoreline, the front wheel slices through the shallow waves and sends spray flying, the old engine roars, she raises one fist and shouts with a laugh: \"Nothing beats this view!\" The camera tracks alongside her. The beach, the rocks and the Golden Gate Bridge stay exactly as in image_1 (same orientation). Keep her face and the motorcycle exactly as in image_1."}')"
SURF=$(jq -r '.result.assets[0].assetId' surf.json)
download "$SURF" surf.mp4

10 seconds at 1280×720 with sound. Muse said "Done. 10 seconds, 16:9 landscape, straight from your image — no edits, no upscaling."

The first try of this exact job failed after 37 seconds: Muse answered that "the video worker glitched out before it rendered anything, so no clip was made". The API reports an answer like that as 503, nothing made, and the same request worked when run again. A refusal on content grounds is a 403 instead, and needs a different prompt.

6. Restore and colorize an old photo

An image job can also repair an image. The old portrait is a faded sepia photo of 685×900 pixels, 3:4. The prompt lists what to fix and insists on the same frame.

run restored.json jobs/image "$(jq -n --arg img "$OLD_PHOTO" '{image_1: $img,
  prompt: "Restore the old photograph image_1 as a high-quality modern photo: remove the scratches, dust, stains, fading and grain, recover sharp detail in the face, hair and fabric, and colorize it naturally (warm natural skin tones, dark brown hair, ivory tulle shawl, a soft pink rose with green leaves, a muted warm background). Keep the exact same person, expression, pose, framing and crop, and the same portrait aspect ratio as image_1 (3:4, 685×900): do not crop, extend or reframe it."}')"
RESTORED=$(jq -r '.result.assets[0].assetId' restored.json)
download "$RESTORED" restored.webp

Before: the original, 685×900
After: restored and colorized, 1344×1792

The result is 1344×1792, the same 3:4 frame at about twice the size, with the same pose and crop. Muse said "Done — restored, de-grained, and colorized, same framing and pose."

7. The portrait comes to life

The restored image goes straight into a video job. The clip keeps the portrait's shape, so it came back 832×1104.

run portrait-video.json jobs/video "$(jq -n --arg img "$RESTORED" '{image_1: $img,
  prompt: "Animate image_1 into a video with the same portrait frame: the young woman slowly lifts her eyes to the camera, her smile widens, she gently touches the rose on her shoulder and says softly: \"It has been a hundred years... and you still remember me.\" A light breeze moves a few strands of her hair, soft window light, the camera stays still with a very slow push-in. Keep her face exactly as in image_1."}')"
download "$(jq -r '.result.assets[0].assetId' portrait-video.json)" portrait.mp4

8. Swap the rider in the video

A video job also takes videos. video_1 is the surf clip from step 5, and image_1 is the photo of a second woman with pink hair in two buns. The prompt asks Muse to replace the rider and keep everything else, and gives her a new line.

run swap.json jobs/video "$(jq -n --arg vid "$SURF" --arg img "$PINK" '{video_1: $vid, image_1: $img,
  prompt: "Edit video_1: replace the rider with the woman from image_1 (her face, pink hair in two buns, colorful makeup and tattoos), and keep everything else the same: the motorcycle, the beach, the waves and spray, the Golden Gate Bridge, the light, the camera move and the timing. Instead of the original line she shouts: \"Catch me if you can, San Francisco!\" Keep the 16:9 frame and the same length."}')"
download "$(jq -r '.result.assets[0].assetId' swap.json)" swap.mp4

Before: the original rider
After: the rider from the photo

At 138 seconds this was the slowest job of the walkthrough, which is why every job here runs async. The clip is the same ride with the other woman on the motorcycle, shouting the new line. Muse said "Done. She's in, 10 seconds, 16:9, same ride, same bridge, same waves."

9. Check the weekly allowance

GET /accounts/email reads the account's plan and usage live:

get "accounts/$(enc "$EMAIL")" | jq '{session, quota}'

quota.percentUsed is the share of the week used, in whole percent, and quota.resetsAt is when it starts over, a week after it began. The three videos above used 2 to 3 percent each and the images 0 or 1. Over the whole test session, which also ran two jobs not shown here, the free account went from 16 to 28 percent. When an account runs out, new jobs without email go to your other accounts, and a job pinned to it answers 412 until resetsAt.

What we learned

Write the aspect ratio as in exactly 16:9 aspect ratio. Cinematic 16:9 landscape photo came back 3:2 once.
Every video is about 10 seconds. A prompt asking for 5 seconds still got 10.
An image-to-video clip keeps the shape of its image unless the prompt asks for another one: in exactly 9:16 aspect ratio turned our 16:9 beach picture into a vertical 720×1280 clip, re-framed rather than stretched.
Lines written in quotes in a video prompt are spoken.
Pass generated files on by assetId. They stay in the account's workspace, so a chain of edits needs no downloads in between.
Say what must stay the same. "Same position, same orientation, not mirrored or redrawn" kept the real beach in the composite.
A 503 with Muse's own words such as "glitched out" is worth running again. A 403 is a refusal and needs a different prompt.
Send videos with async: true. A sync request waits about 100 seconds, and the swap took 138.

Frequently asked questions

Is there an API for Meta Muse (muse.ai)? useapi.net offers one: the Muse API runs Muse on your own account. You add the account with its email and password, then make images with POST /jobs/image and videos with POST /jobs/video.

Does it work on the free Muse plan? Yes. Everything on this page was made on the free plan (HATCH_FREE), which has a weekly allowance. A video used 2 to 3 percent of it and an image 0 to 1 percent.

How do I set the aspect ratio, length or resolution? In the prompt. There are no parameters for them. The aspect ratio is followed when written as in exactly 16:9 aspect ratio. Videos are always about 10 seconds at about 720p, with sound.

Can I use my own photos and videos? Yes. Upload them with POST /assets, up to 8.6 MB each, and pass the assetId as image_1..image_9; video jobs also take video_1..video_3 and audio_1..audio_3. All inputs of one job must be on the same account.

How do I make a photo talk? Pass it as image_1 to POST /jobs/video with a prompt like Animate image_1: … she says softly: "…", as in step 7.

Can it replace a person in a video? Yes. Pass the clip as video_1 and a photo of the new person as image_1, and ask Muse to replace the person and keep everything else, as in step 8.

Why did my sync request return 202? The job was still running after about 100 seconds. It keeps running on our side. Fetch it with GET /jobs/jobid, or send long jobs with async: true.

Why did Muse email me a login code? The API signed in to the account, which happens when you add it and when the session is renewed, about once every 30 days. The code needs no action. See Setup Muse.

Conclusion

Visit our Discord Server or Telegram Channel for any support questions and concerns.

How to Make AI Influencer Videos with Avatars via the Google Vids API

useapi.net — Fri, 09 Oct 2026 05:20:29 +0000

Introduction

The useapi.net Google Vids API makes talking AI influencer videos from avatars: save a picture and one of 30 Gemini voices once with POST /avatars, then pass the avatar's id to any Gemini Omni 1.1 Flash clip, where it speaks the lines you write in the prompt.

The API runs on your own Google Vids account. This walkthrough makes two influencers and launches a sneaker with them. Mia's avatar comes from a portrait made with the API, and Leo's is drawn by Google from a written description. They present the AeroLoop, a made-up sneaker, on a theater stage in one 10-second clip with both avatars and a product image, and two extends take it to 30 seconds. An edit moves the scene to a rooftop, and two more clips show what the same calls make without avatars. Every request below is the one that made the media on this page, with the ids replaced and async: true added by the run helper.

The finished 30-second clip at 720p: one 10-second generation and two 10-second extends (steps 6 to 8).

What it cost

useapi.net is an API, not a video service of its own. Every call runs on a Google account you connect through Setup Google Vids, on a paid Google AI plan, and uses that account's monthly Vids allowance: seconds of video and a count of images. Google AI Ultra $199 gets 10,000 seconds of video and 1,000 images a month. You pay useapi.net a flat $15/month for every API we offer, with no per-clip charge. See Plans and monthly allowances for the other plans.

What each kept result used, taken from the change in result.quota, and how long each job took (result.elapsedMs):

Step	Endpoint	Allowance used	Time
Mia's portrait	POST /images	1 image	9 s
The AeroLoop product shot	POST /images	1 image	9 s
Mia's avatar, from her portrait	POST /avatars	nothing	about 2 s
Leo's avatar, from a description	POST /avatars	1 image	about 20 s
The 10-second launch clip	POST /videos	10 s	38 s
Extend to 20 seconds	POST /videos/extend	10 s	70 s
Extend to 30 seconds	POST /videos/extend	10 s	85 s
Upscale the 20 seconds to 1080p	POST /videos/upscale	20 s	62 s
Rooftop edit	POST /videos/edit	10 s	64 s
Edit of the 30-second clip	POST /videos/edit	10 s	87 s
Product hero clip	POST /videos	10 s	62 s
The pigeon	POST /videos	5 s	54 s
Total		85 s of video, 3 images

An extend uses only the seconds it adds, not the length of the clip. An upscale uses the clip's full length again, and an edit uses the length of the clip it returns. 720p and 1080p cost the same when you generate. A clip you generate again costs its seconds again.

What a 10-second Omni clip costs

Where	One 10-second Omni 1.1 Flash clip	10-second clips a month
Google's metered Gemini API	about $1.01 at `720p`	as many as you pay for
Google Flow API on Google AI Ultra ($199)	15 credits, about $0.12	about 1,666
Google Vids API on Google AI Ultra ($199)	10 seconds of allowance, about $0.20	about 1,000, shared by the family plan
Flow and Vids on the same Ultra account	about $0.07	about 2,666

The Gemini API bills Omni 1.1 Flash at 5,792 tokens per second of 720p video, at $17.50 per million tokens. At that rate, 2,666 ten-second clips would cost about $2,700 a month, against one Ultra plan and the $15 useapi.net subscription. Prices as of October 2026.

Before you start

You need a useapi.net API token and a Google account on a paid Google AI plan connected through Setup Google Vids. A free Google account gets no Vids allowance: it can still be added, but only makes avatars. Every call is also in the Postman collection.

Also in Chinese: 中文教程. The whole pipeline is also on GitHub as one script, in Node.js and Python: influencer-avatars/ in useapi/google-vids-api.

The steps use curl, jq and these variables and helpers:

export USEAPI_TOKEN="user:12345-..."
export EMAIL="user@example.com"
API=https://api.useapi.net/v1/google-vids
AUTH="Authorization: Bearer $USEAPI_TOKEN"
enc() { jq -rn --arg v "$1" '$v|@uri'; }
post() { curl -sS -X POST "$API/$1" -H "$AUTH" -H "Content-Type: application/json" -d "$2"; }
get() { curl -sS "$API/$1" -H "$AUTH"; }
download() { curl -sSf "$API/media/$(enc "$1")" -H "$AUTH" -o "$2"; }

# run a video job async: submit it, poll GET /jobs/{jobid} every 10 s, save the final job record to $1
run() {
  local job id
  job=$(post "$2" "$(jq '. + {async: true}' <<< "$3")")
  id=$(jq -r .jobid <<< "$job")
  while [ "$(jq -r .status <<< "$job")" = processing ]; do
    sleep 10
    job=$(get "jobs/$(enc "$id")")
  done
  echo "$job" > "$1"
  jq '{status, error, duration: .result.duration, resolution: .result.resolution, videoLeft: .result.quota.video.left}' "$1"
}

Every generation runs as a job. Without async, a POST waits up to about 100 seconds and returns the finished job record, or 202 with the job still running. A new 10-second clip took 38 to 62 seconds here, and extends, edits and the upscale took 62 to 87. Some take longer than the sync wait, so run submits video jobs with async: true and polls GET /jobs/jobid. If run prints any status other than completed, stop there and read its error: the lines after it expect a finished clip.

To be called back instead of polling, add replyUrl: "https://example.com/hooks/vids" (and optionally replyRef: "launch-push-in") to any body below. The API then sends one POST of the final job record, as JSON, to that URL when the job completes or fails.

Ids contain : and @, so enc URL-encodes them whenever they go into a URL path. Every input of one video must come from the same Google account. The images and the upload pin email, Mia's avatar inherits the portrait's account, and a video job runs on the account that holds its inputs. The pigeon clip has no inputs, so add email to it if you connect more than one account.

How it was built

1. Mia's portrait

POST /images makes one JPEG per call, here in portrait (9:16, 768×1376) with the photography style.

post images "$(jq -n --arg email "$EMAIL" '{email: $email, aspectRatio: "9:16", style: "photography",
  prompt: "Full-length studio portrait of a confident 24-year-old female fashion influencer, platinum bob, oversized cream hoodie, wide-leg cargo pants, gold hoops, plain light-grey backdrop, facing camera"}')" > mia-portrait.json
MIA_IMAGE=$(jq -r .result.mediaId mia-portrait.json)
download "$MIA_IMAGE" mia-portrait.jpg

Generated images stay available for a few hours only. Make the avatar from it right away, and see the product hero clip for using an image later.

2. The AeroLoop product shot

The same call in landscape (16:9, 1376×768) gives the product reference the clips use.

post images "$(jq -n --arg email "$EMAIL" '{email: $email, aspectRatio: "16:9", style: "photography",
  prompt: "The AeroLoop sneaker: chunky white-and-electric-blue running shoe with a translucent air sole, on a concrete pedestal, dramatic side light, dark background"}')" > aeroloop.json
SHOE_IMAGE=$(jq -r .result.mediaId aeroloop.json)
download "$SHOE_IMAGE" aeroloop.jpg

3. Pick the voices

GET /voices lists the 30 voices with Google's English sample of each. It is public and needs no token. Mia speaks with Aoede (Vids calls it Tova, style "Breezy") and Leo with Puck (Neo, "Upbeat"). POST /avatars takes either name.

curl -sS "$API/voices" | jq -r '.voices[] | "\(.name)\t\(.voice)\t\(.style)\t\(.preview)"'

4. Mia's avatar from her portrait

POST /avatars with image set to the portrait's mediaId saves Mia as an avatar on the same account in about 2 seconds. It costs nothing beyond the image.

post avatars "$(jq -n --arg img "$MIA_IMAGE" '{name: "Mia", voice: "Aoede", image: $img}')" > mia-avatar.json
MIA_AVATAR_ID=$(jq -r .avatarId mia-avatar.json)

{
  "avatarId": "user:12345-user@example.com-avatar:eyJnIjoiaDM5…",
  "name": "Mia",
  "voice": "Tova",
  "voiceId": "Aoede",
  "voiceStyle": "Breezy",
  "voicePreview": "https://ssl.gstatic.com/docs/videos/audio/voice_samples/gemini-v4s-tts/1.1/en/Aoede.wav",
  "email": "user@example.com",
  "source": "image"
}

An avatar cannot be made from your own photo. A real person's avatar is Google's likeness feature, which needs a live selfie video and a phone check in the browser, so POST /avatars refuses an uploaded photo with 400. Use an image made with the API, as here, or a description, as in the next step.

5. Leo's avatar from a description

With appearance instead of image, Google draws the person. outfit and shot are optional, and so are expression and details. Drawing the picture uses 1 image of the allowance, and the response carries it as previewMediaId. In our runs a description avatar came out 1280×720 (16:9), whatever shot we picked.

post avatars "$(jq -n --arg email "$EMAIL" '{email: $email, name: "Leo", voice: "Puck", shot: "upper-body",
  appearance: "a 26-year-old white European male streetwear influencer with short textured hair with a fade and a confident half-smile",
  outfit: "black puffer vest over a white tee, silver chain"}')" > leo-avatar.json
LEO_AVATAR_ID=$(jq -r .avatarId leo-avatar.json)
download "$(jq -r .previewMediaId leo-avatar.json)" leo-avatar.jpg

{
  "avatarId": "user:12345-user@example.com-avatar:eyJnIjoiaDM5…",
  "name": "Leo",
  "voice": "Neo",
  "voiceId": "Puck",
  "voiceStyle": "Upbeat",
  "voicePreview": "https://ssl.gstatic.com/docs/videos/audio/voice_samples/gemini-v4s-tts/1.1/en/Puck.wav",
  "email": "user@example.com",
  "source": "generated",
  "previewMediaId": "user:12345-user@example.com-image:eyJ1IjoiaHR0…",
  "look": {
    "appearance": "a 26-year-old white European male streetwear influencer with short textured hair with a fade and a confident half-smile",
    "outfit": "black puffer vest over a white tee, silver chain",
    "shot": "upper-body"
  }
}

Both avatars stay in the account's Vids document until you delete them with DELETE /avatars/avatarId. GET /avatars lists them, with their ids, whenever you need them again:

get "avatars?email=$(enc "$EMAIL")" | jq -r '.avatars[] | "\(.name)\t\(.voiceId)\t\(.avatarId)"'

6. The launch: two avatars and the product in one clip

POST /videos takes up to 3 references in all, avatars (avatar_1..avatar_3) and images (referenceImage_1..referenceImage_3) together. In the prompt, @avatar_1, @avatar_2 and @referenceImage_1 stand for them, and each avatar speaks its quoted line in its own voice. The product image's mediaId goes in directly: the API fetches the image and uploads it on that account.

10 seconds, 720p, 38 seconds to generate.

The same clip with the visible Gemini ✦ removed by our watermark remover, with one command: python3 vids_watermark_remover.py launch-10s.mp4.

The remover works on clips as generated and on upscales of them, at 720p and 1080p. It does not work on extended or edited clips: Google feeds the marked clip back to the model, which repaints the star into the picture. The invisible SynthID watermark is not touched.

7. Extend to 20 seconds

POST /videos/extend adds 3 to 10 seconds and returns the whole clip with a new mediaId. An extend takes only the clip and a prompt, not the avatars, so the prompt describes the new action and names people by what they wear ("the man in the black puffer vest"). A fan in a red hoodie storms the stage.

PROMPT=$(cat <<'EOF'
A young man in a red hoodie climbs onto the stage from the front right edge and plants himself to the right of the man in the black puffer vest, an arm's length away, so all three stand apart in a row with nobody overlapping. Visibly overexcited, he waves a thick stack of banknotes in his right hand above his head and screams: "Take my money!" The man in the black puffer vest laughs, raises both palms toward him and says: "Whoa, whoa, buddy, be patient!" The blonde woman in the cream hoodie laughs, holding the sneaker. Only these three people are on stage. Same stage, same LED screen with WEAR AEROLOOP, same wide steady shot.
EOF
)
run launch-20s.json videos/extend "$(jq -n --arg id "$LAUNCH_10S" --arg p "$PROMPT" '{mediaId: $id, prompt: $p, duration: 10}')"
LAUNCH_20S=$(jq -r .result.mediaId launch-20s.json)
download "$LAUNCH_20S" launch-20s.mp4

20 seconds, 720p, 70 seconds to generate. It used 10 seconds of allowance, the seconds it added.

8. Extend to 30 seconds

The second extend continues the 20-second clip.

PROMPT=$(cat <<'EOF'
The blonde woman in the cream hoodie turns to the camera with a big smile and says: "AeroLoop drops Friday. Link in bio!" Right after that, the young man in the red hoodie throws ALL of his banknotes out over the audience in one big toss, keeping none, and the bills flutter down over their heads. From then on his hands are completely empty: he holds no money at all. Then all three cheer together, the man in the black puffer vest and the young man in the red hoodie throwing their empty fists in the air, as blue and white confetti rains down over the stage. Only these three people are on stage. Same stage, same LED screen with WEAR AEROLOOP, same wide steady shot.
EOF
)
run launch-30s.json videos/extend "$(jq -n --arg id "$LAUNCH_20S" --arg p "$PROMPT" '{mediaId: $id, prompt: $p, duration: 10}')"
LAUNCH_30S=$(jq -r .result.mediaId launch-30s.json)
download "$LAUNCH_30S" launch-30s.mp4

The result is the finished clip: 30 seconds, 720p, 85 seconds to generate, and again 10 seconds of allowance. You can keep going: chains of extends work up to 40 seconds, for example four 10-second steps. Past that, Google keeps only about the first 31 seconds of the source and adds the new seconds after them, so the longest clip is about 41 seconds.

9. Upscale to 1080p

POST /videos/upscale turns a 720p clip into 1080p and keeps its length. It works on clips of up to 20 seconds, so we upscaled the 20-second clip from step 7, not the 30-second one. It used the clip's 20 seconds again and took 62 seconds.

run launch-20s-1080p.json videos/upscale "$(jq -n --arg id "$LAUNCH_20S" '{mediaId: $id}')"
download "$(jq -r .result.mediaId launch-20s-1080p.json)" launch-20s-1080p.mp4

The 20-second clip, upscaled to 1920×1080.

Why not the 30-second clip: Google returned it at 1920×1080, but with its frames out of order, three times out of three. The confetti ending flickered in before the fan arrived. The 20-second clip came back in order, and the Vids editor itself stops at 20 seconds, so the API refuses upscales of clips longer than 20 seconds with 400, before anything is charged.

So for a 1080p clip:

Make, extend and edit at 720p.
Upscale the clip once it is finished, while it is 20 seconds or shorter.
For a longer clip, stay at 720p, set resolution: "1080p" on the last extend only, or extend at 1080p throughout and accept softer faces.

Examples

More from the same account and inputs: an edit, a product clip from a start image, and a text-only clip.

Move the launch to a rooftop

POST /videos/edit changes a generated clip by prompt and returns a new clip. The source goes in video. This edit of the 10-second launch clip used 10 seconds and took 64 seconds.

run launch-rooftop.json videos/edit "$(jq -n --arg v "$LAUNCH_10S" \
  '{video: $v, prompt: "Move the whole scene to a rooftop at sunset, with the city skyline behind them. Same two people, same action, same words."}')"
download "$(jq -r .result.mediaId launch-rooftop.json)" launch-rooftop.mp4

An edit works on up to 10 seconds. The same edit of the 30-second clip, with "Same three people", came back 10 seconds long: the first 10 seconds, moved to the rooftop. It used 10 seconds of allowance. To get a longer edited clip, edit the 10-second clip and extend the result, since an extend accepts an edited clip.

The edit of the 30-second clip: 10 seconds back.

A product hero clip from a start image

With startImage the clip opens on that image. A generated image's link expires within hours, so we uploaded the saved aeroloop.jpg with POST /assets and passed its assetId. A single clip has no extends, so it was made at 1080p directly.

SHOE_ASSET=$(curl -sS -X POST "$API/assets?email=$(enc "$EMAIL")" -H "$AUTH" -H "Content-Type: image/jpeg" \
  --data-binary @aeroloop.jpg | jq -r .assetId)
run hero.json videos "$(jq -n --arg img "$SHOE_ASSET" '{startImage: $img, duration: 10, resolution: "1080p", aspectRatio: "landscape",
  prompt: "Slow 360° orbit around the sneaker, blue light rippling through the translucent sole, dust sparkling in the air, cinematic."}')"
download "$(jq -r .result.mediaId hero.json)" hero.mp4

10 seconds, 1080p.

A pigeon in AeroLoops

A text-only clip, in portrait at 1080p (1080×1920). The 5 seconds took 54 seconds to generate and used 5 seconds of allowance.

run pigeon.json videos "$(jq -n '{duration: 5, resolution: "1080p", aspectRatio: "portrait",
  prompt: "A pigeon in tiny white-and-electric-blue AeroLoop sneakers struts down a city sidewalk like a runway model, head bobbing to the beat. Pedestrians stop and film it with their phones. It pauses, does a slow-motion hair flip with its head feathers, and struts on. Funny, sunny, shot on a phone at pigeon height."}')"
download "$(jq -r .result.mediaId pigeon.json)" pigeon.mp4

The pigeon at 1080p portrait (1080×1920), with the ✦ removed the same way: python3 vids_watermark_remover.py pigeon-5s.mp4. The script reads the frame size, works out where the star is and how big (it scales with the short side, so here it is 1.5 times the 720p star), reverses the blend on all 120 frames, re-encodes the video at CRF 18 and copies the audio unchanged. The 5-second clip took about 10 seconds on a 14-core PC, the same as the 10-second 720p launch clip above. It needs Python 3.8+, numpy and ffmpeg; see the watermark remover on GitHub.

What we learned

A 1080p clip behaves like an upscaled 720p one. Build a chain of extends at 720p: at 1080p the faces got softer and more waxy at every step.
Upscale only clips of up to 20 seconds. Our 30-second upscale came back with its frames out of order every time.
Generate a single clip at 1080p if you want 1080p and won't extend it. It costs the same as 720p.
Write an extend prompt about the new action only. The extend gets the clip, not the avatars, so name people by what they wear.
Put a prop in a person's hands in the first sentence that mentions them. A verb like "lifts" made the sneaker appear from nowhere.
Say what must not happen. The fan kept a stack of banknotes until the prompt said his hands were empty.
Reuse avatars by avatarId. Each avatar is a fixed picture and voice, kept until you delete it.
Make avatars and clips from a generated image within a few hours, or upload the saved file with POST /assets first.
Edit clips of up to 10 seconds. A longer clip comes back as its first 10 seconds.
Expect on-screen text to waver. The backdrop's "WEAR AEROLOOP" is misspelled in some frames.
Every MP4 has Google's visible Gemini ✦ in the bottom-right corner and an invisible SynthID watermark (see Watermark). Our watermark remover takes the visible sparkle off a downloaded clip.

Frequently asked questions

How do I make an AI influencer video through an API? Create an avatar with POST /avatars, from a description or from an image made with POST /images, and give it a voice from GET /voices. Then pass its avatarId as avatar_1 to POST /videos and write its lines in quotes in the prompt.

Can I make an avatar from my own photo? No. Google treats an avatar of a real person as its likeness feature, which needs a live selfie video and a phone check in the browser. The API refuses an uploaded photo with 400. Use a picture made with POST /images or describe the person with appearance.

How many avatars can one clip have? Up to 3 references in all, avatars and images together. This walkthrough used two avatars and one product image.

Does an avatar look and sound the same in every video? It uses the same picture and the same voice every time you pass its avatarId, since both are saved with the avatar in the account's Vids document. The clip around it still varies from take to take. GET /avatars lists your avatars, including ones made in the Google Vids web app.

Can two avatars talk to each other in one clip? Yes. Pass avatar_1 and avatar_2 and give each a quoted line in the prompt, as in step 6.

Can I make a vertical 9:16 video for TikTok or Reels? Yes. Set aspectRatio: "portrait" on POST /videos for 720×1280, or 1080×1920 at 1080p, as in the pigeon clip. An extend can also turn a landscape clip into portrait.

How long can a video be? A generated clip is 3 to 10 seconds. Extends add 3 to 10 seconds each, up to about 41 seconds in all, and each one uses only the seconds it adds.

What does it cost? A flat $15/month to useapi.net, plus the Vids allowance of your own Google AI plan: Ultra $199 gets 10,000 seconds of video and 1,000 images a month. Everything kept on this page used 85 seconds and 3 images (see What it cost).

Why did my sync request return 202? The job was still running after about 100 seconds. It keeps running on our side. Fetch it with GET /jobs/jobid, or send long jobs with async: true.

Conclusion

Visit our Discord Server or Telegram Channel for any support questions and concerns.

Check our GitHub repo with code examples.

How to Turn Web Pages, YouTube Videos and RSS Feeds into NotebookLM Podcasts with n8n

useapi.net — Mon, 05 Oct 2026 05:53:18 +0000

Introduction

Two free n8n workflows send your links to NotebookLM through the useapi.net NotebookLM API (Gemini Notebook API) and bring back the finished podcast as an .m4a file. One is a form where you paste web pages and YouTube videos. The other watches a blog's RSS feed and turns every week's new posts into one episode. Both use only core n8n nodes and run on your own Google account, including a free one.

The episode below came from the RSS workflow, pointed at Google's AI blog feed with format set to brief and length to short. Run once by hand, it picked up the two posts from the past week and produced a 1 min 43 s episode in 3 min 23 s.

🎧 Play on useapi.net
"Google AI Fights Cyberattacks and Disease", made by the RSS workflow from the Google AI blog feed, brief format, short length, 1 min 43 s, generated in 3 min 23 s

The two workflows

Workflow	What it does	File
Links to podcast	A form: paste web pages and YouTube links, pick a format and a length, get the `.m4a` back	`notebooklm-podcast.json`
RSS feed to weekly podcast	Every Monday at 7:00, the newest posts of a feed become one episode	`notebooklm-rss-podcast.json`

Both files are in the notebooklm-api repository on GitHub, MIT-licensed. They were tested on self-hosted n8n 2.41.

How they work

The form workflow asks for a title, the links (up to 50, one per line), the podcast format and the length. Then it:

creates a notebook with POST /notebooks and adds the links with POST /sources.
checks the notebook every 10 seconds until Google has read every source.
starts the Audio Overview with POST /artifacts and polls GET /jobs every 20 seconds.
downloads the .m4a as binary data for the next node.

The RSS workflow does the same from a Schedule Trigger. It reads the feed, keeps the posts published in the last lookbackDays days (7 by default), newest first and at most maxPosts (5), and puts them in one notebook named <showName>, <date>. A week with no new posts makes no episode. The schedule runs in your n8n instance's time zone.

The formats are deep_dive, brief, critique and debate, and the lengths are short, default and long. The Settings node (form) or Feed settings node (RSS) also holds language, for example es, pt_BR or zh_Hans, and email, which you leave empty unless you want one specific Google account.

Set it up

Get a useapi.net API token and connect your Google account with the NotebookLM setup.
In n8n, import the file with Workflows → Import from File.
Create a Header Auth credential, for example called useapi.net API token, with Name Authorization and Value Bearer <your API token>.
Select that credential on the six HTTP Request nodes: Create notebook, Add sources, Check sources, Generate Audio Overview, Check job and Download audio.
For the form, click Execute workflow to test it, or publish (activate) the workflow and open its form URL. For RSS, put your feed in the Feed settings node, click Execute workflow to try it, then publish (activate) it.

A short brief takes about 3 to 10 minutes. Add a Google Drive, S3, Telegram or podcast-host node after Download audio to send each episode where you need it. If you change the RSS schedule, change lookbackDays to match, for example a daily run with lookbackDays: 1.

When something goes wrong

A 401 on the first HTTP node means the credential is missing or the token is wrong. Check that the value starts with Bearer.
A 429 on Generate Audio Overview means the Google account is out of NotebookLM usage for now, and the run stops there. The response carries retryAt when Google names the reset time. To make more episodes, connect more Google accounts through the NotebookLM setup and leave email empty. New notebooks then go to the least busy account, so the next run can land on one that still has usage.
A failed job stops the workflow with the error Google returned.
A source that ends in error, for example a YouTube video without captions, is skipped and the episode uses the rest.
The workflows keep polling until the sources are read and the job finishes. Stop a run that has been polling for more than about 20 minutes.

What it costs

A flat $15/month for useapi.net, which covers every useapi.net API. There is no charge per episode. NotebookLM's usage limits come from your Google plan, and each subscription lets you connect 3 Google accounts, up to 100 in total, to make more. See Run NotebookLM at scale.

More ways to use the NotebookLM API

A real example: one podcast, a video overview and an infographic from the same two sources.
The full tutorial: every Studio output, chat with citations and Deep Research, with curl.
GitHub examples: Node.js, Python, a Colab notebook and an agent skill for Claude Code and Codex.

Frequently asked questions

Does NotebookLM have an API? Google offers a NotebookLM Enterprise API to Google Cloud customers with Enterprise licenses. Of the Studio outputs, it makes Audio Overviews only. The useapi.net NotebookLM API drives your own Google account instead, free or paid, and covers every Studio output.

Do I need n8n Cloud? No. Both workflows use only core nodes. They were tested on self-hosted n8n and need nothing Cloud-only.

Start using the API

Subscribe — $15/month

Pricing, crypto payment, and volume options — full refund within the first 14 days if you have fewer than 50 successful generations.

How to Make UGC Video Ads in n8n with the Google Flow API

useapi.net — Sun, 04 Oct 2026 00:25:41 +0000

Introduction

A free n8n template makes AI UGC video ads through the useapi.net Google Flow API: one form, up to five products, a consistent Omni 1.1 Flash presenter and voice, and 140 Flow credits for the default ad with four takes of each clip. There is no code to write. You open one form URL and click through it, and every free step has a page to pick or re-roll before the clips spend any credits.

UGC ads are the one-person-talking-to-a-phone videos that fill TikTok, Reels and Shorts. Making them with AI is easy to start and hard to finish, because the presenter's face drifts, the voice changes from clip to clip, and the product on the table turns into a different product. This workflow is built around those three problems. The face and the voice are saved together as one character, every product gets a four-view reference sheet or your real photo, and every clip is filmed in one scene you picked.

The video model is Omni 1.1 Flash, Google's audio-native model, so the presenter speaks the lines you write, in the voice you picked, with lip sync, in one generation. If you would rather do it in code, the UGC product video tutorial builds a similar video with plain API calls in first-and-last-frame mode, which pins the set exactly but cannot carry a picked voice.

"My beauty secrets", a deadpan parody ad
made with this n8n template, 1080p, 32 seconds

What you need

An n8n instance. The workflow uses only core n8n nodes, with no community nodes. It was tested on self-hosted n8n 2.41.
A useapi.net account with an API token. One $15/month subscription covers every useapi.net API, with no per-call surcharge.
A Google account connected to useapi.net, on a paid Google AI plan. Omni 1.1 Flash video needs a paid plan and spends its Flow credits.

How to import the n8n UGC ad template

Download ugc-ad-factory.json from the example repo, and in n8n choose Workflows → Import from File.
Create a Header Auth credential whose Name is Authorization and Value is Bearer <your API token>, then select it on every HTTP Request node.
Publish (activate) the workflow and open the URL of the Start form node.

The form is the whole interface. Nothing in the canvas needs editing to make an ad, and the defaults produce a working ad on the first run: a friendly presenter at a bathroom vanity showing a vitamin C serum, with a short intro and a call to action at the end.

The pages, one by one

Setup

The first page asks only for the shape of the ad: the Google account email, where the presenter comes from, how many products (1 to 5), whether to add an intro and a closing clip, vertical 9:16 or horizontal 16:9, and how many takes to film of each clip (1 to 4, default 4). The next page then asks for exactly that many details, with no empty fields.

Details

Here you describe the presenter, the voice, the scene and every clip. Each clip is one sentence of action plus the line in quotes, for example: The presenter picks up the serum, holds it up so the label faces the camera, and says: "This vitamin C serum goes on first every morning."

Depending on what you chose on the setup page, this page can take photos or an ID instead of descriptions:

Photos of the presenter. One clear photo is enough, and a second one in three-quarter view saves a step. Google screens real faces, so a photo of a real person may be refused when the video is made.
A saved character ID from an earlier run on the same Google account. It brings the face and the voice, and skips the next three pages.
A photo of each product. It is used as it is, or turned into a four-view sheet if you choose that option.

Presenter and second angle

Four presenters are generated from your description. Pick one, or re-roll four new ones with a note such as "older, shorter hair". The next page makes four three-quarter views of the same face, because a second angle helps the face hold in video. A single uploaded photo starts the workflow at the second-angle page, and two photos skip straight to the voice.

Voice

Four of Google's preset voices read your sample line, and you play them in the page. Pick one, or ask for four more, optionally with a new delivery note such as "calmer, British accent". The picked voice and the two angles are saved as one character, and that character is used in every clip, which is what keeps the voice the same across the ad.

Product images

Each product gets four reference sheets, each showing the same product from four angles. Pick one per product, or re-roll any single product while the others keep their picks. An uploaded photo appears as it is, with nothing to choose.

Scene

Four candidates of the presenter with every product in one frame. Every clip is filmed in the scene you pick, so this is where you choose the set, the framing and where each product stands. This page is the last free step, and it shows what the clips will cost before you continue, for example "3 clips × 4 takes ≈ 140 credits".

Takes

All the takes play in the page, one row per clip. Pick the best take of each clip, or re-roll only the clips you don't like. If Google refuses a clip, the page shows why and puts the clip's action in an editable box. In testing, a refused "lifts the shears in front of the chest" went through on the first try as "points at the shears on the table". Choose 1080p or 720p for the final video.

Your ad

The last page plays the finished ad and links the MP4. The MP4 is joined on request by the workflow's own download URL, so nothing is stored in n8n, and the clips stay in your Flow account. Your n8n URL must be reachable from the browser you use. If a join between two clips has a pause or clips a word, set how much is cut from the start or end of each clip and re-join, which is free and takes about half a minute. The page also shows the character ID, so the same presenter, with the same face and voice, can front your next ad.

How long it takes

The image pages are quick, and slower when captcha needs retries. The clips take 5 to 15 minutes, and the upscale and join a few more. While a step runs, the button turns into a status panel that says what is being made, how long it usually takes, and how long it has been working. Refreshing the page brings you to the next one when it is ready.

How much does an AI UGC ad cost?

Everything except the video clips is free: the presenters, angles, voices, character, product sheets, scenes, the 1080p upscale and the final join. Each Omni 1.1 Flash take spends Flow credits from your Google AI plan, the same as making it in Flow yourself: 7, 10, 12 or 15 credits for a 4, 6, 8 or 10 second clip at 720p.

The default ad is a 6-second intro, one 10-second product clip and a 6-second closing, which is 35 credits per round of takes and 140 credits with four takes of each clip.

The same ad on the official Gemini API is billed per second of video and per image. Omni 1.1 Flash costs about $0.10 per second of 720p video there, and a Nano Banana Pro image $0.134. The table compares one finished ad with four takes of every clip and one round of images, before any re-rolls, leaving out the flat useapi.net subscription:

Ad (4 takes per clip)	Official Gemini API	useapi.net, Flow Pro	useapi.net, Flow Ultra
Default: intro 6 s, one product 10 s, closing 6 s	$11.06	$2.80	$1.40
Parody above: intro 6 s, three products 10 s each	$17.81	$4.40	$2.20
Largest: intro 6 s, five products 10 s each, closing 6 s	$29.43	$7.60	$3.80

The official column is the video seconds at $0.10 plus the images at $0.134 each (16, 24 and 32 images). The useapi.net columns are the Flow credits at about $0.02 each on Pro and $0.01 on Ultra, with images free. That is about 4 times cheaper on Pro and 8 times cheaper on Ultra, and every re-roll of an image costs nothing instead of $0.134. The per-plan figures come from the Google Flow price comparison.

Re-rolling a clip costs its takes again, and a refused clip costs nothing. The full credit table is on POST /videos.

How to keep the face and voice consistent across clips

One character holds the face and the voice. It is made from two angles of the presenter plus the voice you picked, through POST /characters.
Every clip is filmed in reference mode with up to four inputs: the character, the scene you picked, the product handled in that clip (if any), and the voice. In the test ads the voice stayed within the range a single speaker covers from line to line, across every clip.
Each clip's action ends with the presenter putting the product back where it was, so the table looks the same at every cut.
Takes absorb the rest. Reference mode lets the model reinterpret the scene a little, so framing can shift slightly between clips and the occasional take is off. Several takes per clip give you a choice, and picking costs nothing extra.

When something goes wrong

Every API call's result is sorted into one of three kinds, and each kind is handled differently.

Kind	Examples	What the workflow does
Temporary	captcha failures, `429`, Google `503`	Retries automatically, up to five times 5 seconds apart, then shows the failure with a re-roll, or a stop page if the character can't be created. A clip that already went through is never submitted twice
Refused	Google's content filters, such as `PUBLIC_ERROR_DANGER_FILTER`	Shows the reason and asks you to change the description or the action
Dead end	a wrong token, an account that isn't connected, a plan that can't use the model	Stops with a page that says what to fix

The account, its plan and its Flow credits are checked right after the details page, and the credits again just before the clips, so a dead end stops the run before anything is spent.

If upscaling a clip fails, that clip stays 720p and the last page offers to retry just the failed ones, which is free.

Customize it

The Settings node holds the defaults for the details page, the image model (nano-banana-pro) and the number of captcha attempts per request. The clip prompt is in the Clip requests node. Everything the workflow calls is a documented endpoint, so any step can be changed with the Google Flow API reference at hand.

Examples

Both were made with this workflow and are Omni 1.1 Flash output, re-encoded to a smaller size for hosting.

"My beauty secrets", a parody beauty ad
made with this n8n template, 1080p, 32 seconds Uploaded presenter photo and product photo
coffee, two products, 16:9, 15 s

Frequently asked questions

Do I need to write any code? No. You import one JSON file, add one credential and open a form. The workflow can be read and changed in n8n like any other, but making an ad never needs it.

Can I use my own product photos? Yes. Upload a PNG, JPEG or WebP of up to 20 MB on the details page. It is used as it is, or turned into a four-view sheet if the product gets turned around on camera.

Can I use a real person as the presenter? You can upload photos of a presenter, but Google screens identifiable people, so a real face may be refused when the clips are made. A generated presenter avoids that, and the saved character ID lets you reuse the same one in every ad on the same Google account.

Does the voice stay the same in every clip? Yes, when the character has a voice, which every character this workflow creates does. The voice you pick is saved in the character together with the face, and every clip is made from that character. Picking from four previews also means you hear the voice before any clip is made.

Can it make square videos? No. Omni 1.1 Flash makes vertical (9:16) and horizontal (16:9) video, and the form offers those two formats.

How many products can one ad show? Up to five, each with its own clip, plus the optional intro and closing, so seven clips at most.

Does it work on n8n Cloud? It uses only core n8n nodes, so it should, but it has only been tested on self-hosted n8n 2.41. The one requirement is that the browser can reach your n8n URL, because the last page plays the ad from the workflow's own download URL.

How long does one ad take? The free pages are quick, and every re-roll adds a little. The clips take 5 to 15 minutes, and the upscale and join a few more.

What does an ad cost? The useapi.net subscription is a flat $15 a month, and the clips spend the Flow credits of your Google AI plan, 7 to 15 per take depending on length. The default ad with four takes per clip is 140 credits. See the cost section.

Conclusion

Visit our Discord Server or Telegram Channel for any support questions and concerns.

Check our GitHub repo with code examples.

How to Automate NotebookLM with the Gemini Notebook API: Deep Research, Chat, Audio Overviews and a Lot More

useapi.net — Wed, 30 Sep 2026 03:43:30 +0000

Introduction

The useapi.net Gemini Notebook API is a REST API for Google's Gemini Notebook, formerly NotebookLM, that you can call from any language that can send an HTTP request. It drives your own Google account: notebooks, sources, grounded chat, notes, web research, sharing and every Studio artifact. It also runs unattended: jobs spread across your connected accounts by remaining usage and are tracked server-side, so nobody has to watch the usage limits or decide when the next batch can start (see the FAQ).

Four sources and two research questions went in, and 30 minutes of API calls later the notebook held an Audio Overview, an 11-minute Video Overview, a slide deck, an infographic, a Deep Research report and every text artifact Studio makes. Everything below is real output, and every call that made it is further down the page.

Sources and prompts

Input	What it is
Web page	Apollo 11 on Wikipedia, 27,095 words
YouTube video	A New Look at the Apollo 11 Landing Site, NASA Goddard
Pasted text	One paragraph, "Why Apollo 11 almost did not land"
PDF upload	The same Wikipedia article as a 3.8 MB PDF
Chat question	"What went wrong during the descent, and how did the crew handle it?", then "How much fuel was left when they landed?"
Discover sources	"Apollo 11 lunar module guidance computer alarms"
Deep Research	"Why did the Apollo 11 landing nearly abort?"

Results

Video Overview — explainer, whiteboard style, 11 min 50 s
the first 90 seconds, cut without re-encoding for our media host · [step 18](#18-a-video-overview-and-a-slide-deck)

Slide deck — presenter format, 8 slides, pdf + pptx
[the whole deck as PDF](https://demo.useapi.net/discord-cdn-proxy/?https://cdn.discordapp.com/attachments/1239264794394234985/1554374611972530217/gemini-notebook-tutorial-pro-slides-presenter-apollo11-deck-0929.pdf) · [step 18](#18-a-video-overview-and-a-slide-deck)

Slide 2 as generated

Slide 2 revised — "Make this slide a simple timeline graphic."
51 seconds · [step 19](#19-revise-one-slide)

Infographic — portrait, sketch note, 1536 × 2752
1 min 45 s · [step 11](#11-an-audio-overview-and-an-infographic)

Result	What came back	Time
Chat answer	4,237 characters with 21 numbered citations, and a follow-up in the same conversation	35 s
Discover sources	10 web pages with one-line descriptions, 3 imported	16 s
Deep Research	A 26,878-character cited report on 30 web sources, imported as a source	3 min 40 s
Quiz	6 questions with answer options, hints and rationales	33 s
Flashcards	20 cards	18 s
Mind map	A JSON tree of the whole topic	92 s
Briefing report	27,282 characters of Markdown	79 s
Data table	12 rows of alarms and anomalies with their causes	32 s
Source guide	Google's summary and key topics of the Wikipedia page	1 s

Studio action	Free	Pro	Ultra
Audio Overview	2	9	181
Video Overview	2	9	183
Video Overview, short	2	11	229
Video Overview, cinematic	not available	1	25
Report	23	92	1846
Table	16	67	1355
Quiz	43	175	3478
Flashcards	52	212	4285
Infographic	9	37	745
Slide deck	1	7	146
Mind map	66	263	5217
Chat question	62	243	4897

Time	Alarm or event	Cause	What the crew or Mission Control did
Five minutes into the descent burn / MET 102:38:00–102:38:22 / PDI + 316 seconds	1202 program alarm	Computer overload (Executive overflow: no core sets available). High-frequency counter increment requests …	Buzz Aldrin checked the alarm code using Verb 90 Noun 50 (and Verb 05 Noun 09 at PDI + 322 seconds). Computer …
MET 102:36:55	Slow spacecraft rotation rate during pitch-over/spin maneuver	Autopilot rate switch was set at 5 deg/sec.	Neil Armstrong switched the autopilot rate switch from 5 deg/sec to 25 deg/sec.
As descent began / Not in source	Overshooting the Planned Landing Target / Downrange Position Offset (Trajectory shifted 3,000 ft downrange …	Residual pressure in the docking tunnel during separation, lunar gravitational anomalies (mascons), and …	The crew monitored their position closely, maintained composure, and prepared to adapt to landing further …

Step	Endpoint	What it does
Create a notebook	POST /notebooks	Creates an empty notebook on one of your connected accounts.
Add sources	POST /sources	Web pages and YouTube videos (`urls`, up to 50 per call), pasted `text` and Google Drive files (`drive`).
Upload a file	POST /sources/upload	The file is the raw request body: PDF, Word, PowerPoint, EPUB, Markdown, text, CSV, audio, video or an image.
Read a source	GET /sources/`source`	Google's summary and key topics of one source, and with `content=true` the text Google indexed.
Ask	POST /chat	An answer from the sources with numbered citations. Pass `conversation` for a follow-up.
Keep notes	POST /notes	Notes in the notebook. A note can become a source.
Research	POST /research	`fast` finds sources on the web in seconds, `deep` runs Deep Research and writes a cited report.
Import research	POST /research/import	Adds the sources a research run found, and its report, to the notebook.
Generate	POST /artifacts	`audio`, `video`, `report`, `interactive_report`, `table`, `quiz`, `flashcards`, `mindmap`, `infographic` or `slides`, each with its own options.
Revise a slide	POST /artifacts/revise	Redraws one slide of a finished deck from a prompt.
Follow a job	GET /jobs/`jobid`	The status and, once finished, the result.
Download	GET /artifacts/download	The artifact's file (`m4a`, `mp4`, `pdf`, `pptx`, `png`), streamed with your API token.
Share	POST /sharing	Invite people as viewers or editors, turn the public link on or off, and limit viewers to chat only.
Copy a notebook	POST /notebooks/copy	A copy with every source and Studio artifact, on the same account.
Notebook guide	GET /notebooks/guide	Google's summary of the whole notebook, suggested reports and suggested chat questions.
Chat history and settings	GET /chat, DELETE /chat, POST /chat/settings	A conversation's turns, delete the history, and set the chat's goal, persona and answer length.
Source labels	POST /labels	Google labels the sources by topic, or you make and edit your own labels.
Mind map note	POST /notes/mindmap	A mind map made in one call and kept as a note.
Output language	POST /accounts	The language Google writes Studio artifacts in, for the whole account.

Model id	Marketing name	References (I2I)	Aspect ratios	Notes
`nano-banana-2-lite` (default)	Nano Banana 2 Lite / Gemini 3.1 Flash-Lite Image	max 10	16:9, 4:3, 1:1, 3:4, 9:16, auto^†	Google Flow's default image model since July 2026 — stays at 16:9 in image-to-image mode unless you pass a ratio
`nano-banana-2`	Nano Banana 2 / Gemini 3.1 Flash Image	max 10	16:9, 4:3, 1:1, 3:4, 9:16, auto^†	Defaults to `auto` in image-to-image mode
`nano-banana-pro`	Nano Banana Pro / Gemini 3 Pro Image	max 10	16:9, 4:3, 1:1, 3:4, 9:16, auto^†	Highest-quality image model — defaults to `auto` in image-to-image mode

Model	Official Gemini API	useapi.net (Flow Pro)	useapi.net (Flow Ultra)
Veo 3.1 Fast — 8s clip	$0.80	~$0.40	~$0.10
Veo 3.1 Quality — 8s clip	$3.20	~$2.00	~$1.00
Veo 3.1 Lite — 8s clip	$0.40	~$0.20	~$0.05
Veo 3.1 Lite, lower priority	—	—	$0 (Ultra $199)
Omni 1.1 Flash — 8s clip	— (Flow only)	~$0.24	~$0.12
Omni 1.1 Flash — 8s clip at 360p	— (Flow only)	~$0.12	~$0.06
Nano Banana Pro — per image	$0.134	included	included
Nano Banana 2 — per image	$0.067	included	included
Nano Banana 2 Lite — per image	$0.034	included	included

Free workload (no Flow credits spent)	Avg generations / day*
Veo 3.1 Lite — lower priority video	~1,000
Images — Nano Banana 2 Lite, Nano Banana 2, Nano Banana Pro	up to ~500

	Endpoint	Text limit	You get
Short and simple	POST speech/create-mp3	3,000 characters	The finished MP3 URL in one call
Anything longer	POST speech/create	5,000, or 10,000 on `turbo`	An `audioId` straight away, plus a `replyUrl` callback
Start playing sooner	POST speech/create with `"stream": true`	5,000, or 10,000 on `turbo`	The audio streamed back as it renders, so playback can start before it is finished

Model	Max characters	Credits per character	Status
`speech-2.8-hd`	5,000	1	Current, and the default
`speech-2.8-turbo`	10,000	0.6	Current
`speech-2.6-hd`	5,000	1	Previous generation
`speech-2.6-turbo`	10,000	0.6	Previous generation
`speech-2.5-hd-preview`	5,000	1	Superseded by 2.6
`speech-2.5-turbo-preview`	10,000	0.6	Superseded by 2.6
`speech-02-hd`	5,000	1	Legacy
`speech-02-turbo`	10,000	0.6	Legacy
`speech-01-hd`	5,000	1	Legacy
`speech-01-turbo`	10,000	0.6	Legacy

Model	Vendor	Route	Six seconds	Notes
Omni 1.1 Flash	Google	Google Flow API	$0.08	generates at 360p or 720p, free upscale to 1080p
Kling v3	Kuaishou	Kling API	$0.44	up to 4K, derives aspect from the frame
MiniMax H3	MiniMax	PixVerse API	$0.72	768p or 1440p, no 720p tier
Seedance 2.5	ByteDance	PixVerse API	$1.80	reference audio and video, via create-fusion

Model	Through useapi.net	The vendor's own API
TemPolor v4.8 / i4	$30/month, unlimited tracks — no per-track rate at all	$0.04/call in prepaid credits — $100 to $5,000 a package, no bulk discount
MiniMax Music-3.0	$0.010/track	$0.15/composition, +$0.01 if it writes the lyrics — 15×
Google Lyria 3.5	$0.011/track	$0.08/song — 7×
Mureka V9.5	$0.0135/track	$0.03/song, and the plan starts at $1,000/month — 2×

Route	Poll	Finished when	The file
PixVerse	GET /videos/{video_id}	`video_status_final: true`	`url`
Google Flow	GET /jobs/{jobId}	`status: "completed"`	`fifeUrl` on the returned media
Kling	GET /tasks/{task_id}	`status_final: true`	`works[0].resource.resource`

Step	Model	Credits	Cost
Character portrait, 9:16	Nano Banana Pro	0	$0
Four start frames, 9:16	Nano Banana Pro	0	$0
Clip 1, Sora 2, 8s 720p, trimmed to 6s	`sora-2`	160	$0.64
Clip 2, Seedance 2.5, 6s 720p	`seedance-2.5`	450	$1.80
Clip 3, Omni 1.1 Flash, 6s 720p	`omni-flash`	10	$0.08
Clip 4, MiniMax H3, 6s 768p	`minimax-h3`	180	$0.72
Clip 5, Kling v3, 6s 1080p	`kling-v3-0`	72	$0.44
Total			$3.68

Step	Mode	Credits
Three product sheets, 1:1	Nano Banana 2 Lite	0
Two presenter portraits, 3:4	Nano Banana 2 Lite	0
The character	—	0
The still, 9:16	Nano Banana 2 Lite, character + 3 references	0
Clip 1, the mug, 10s	I2V, first + last frame	15
Clip 2, the desk robot, 10s	I2V, first + last frame	15
Clip 3, the keyboard, 10s	I2V, first + last frame	15
Upscale, three clips to 1080p	—	0
Concatenate	—	0
Total		45

Service	July	Now	What moved
TemPolor	not in the line-up	v4.8 (songs) + i4 (instrumentals)	new to this comparison, and two new models
Mureka	V9	V9.5	new default model
Flow Music	Lyria 3 Pro	Lyria 3.5	new flagship — but 3 Pro is still the API default
MiniMax	music-2.6 via PixVerse	Music-3.0, native	new model and a new endpoint