Luma Labs
Create and manage AI image and video generations and reusable files through the current Luma Agents API.
Verdict
Common use cases
- Generate product mockups from text briefs
- Edit video clips for social media
- Extract layered assets from concept art
- Prototype hero images for landing pages
- Create storyboard frames during creative reviews
Integration
- Vendor
- Luma Labs
- Category
- other
- Auth
- API_KEY
- Tools
- 11
- Composio slug
luma_labs
Tools
- Delete Filedestructive
Soft-delete a Luma file so new generations cannot reference it. The file's metadata remains retrievable with state=deleted.
- Edit Image
Submit a paid, asynchronous Luma image-edit job. Returns immediately; use GET_GENERATION with generation_id to monitor it.
- Edit Video
Submit a paid, asynchronous Ray 3.2 video-edit job. Returns immediately; use GET_GENERATION with generation_id to monitor it.
- Extract Image Layers
Submit a paid, asynchronous Luma image layer-extraction job. Pricing is flat per generation at the selected resolution, regardless of layer count; use GET_GENERATION with generation_id to monitor the job.
- Generate Image
Submit a paid, asynchronous Luma image generation job. Returns immediately; use GET_GENERATION with generation_id to monitor it.
- Generate Video
Submit a paid, asynchronous Ray 3.2 video generation job. Returns immediately; use GET_GENERATION with generation_id to monitor it.
- Get File
Get a Luma file's metadata and current ingest, moderation, or deletion state. Soft-deleted files remain retrievable with state=deleted.
- Get Generation
Get the current state, failure details, and output URLs for a Luma generation.
- List Files
List files in the connected Luma account, newest first, with optional state and purpose filters. Returns one page and a cursor for continuation.
- Reframe Video
Submit a paid, asynchronous Ray 3.2 video-reframe job. Returns immediately; use GET_GENERATION with generation_id to monitor it.
- Upload File
Directly upload file bytes to Luma and return the file ID, metadata, and current upload/ingest state.
Setup
Setup guide
- 11. In Switchy, open Settings → Integrations and click Connect next to Luma Labs. 2. You'll be prompted for a Luma API key; generate one at lumalabs.ai/dashboard/api-keys (requires a Luma account with billing enabled). 3. Paste the key and click Authorize. 4. Switchy confirms the connection and shows 11 available tools. 5. Open any Project, type '@Luma Labs generate an image of a sunset over mountains' and send. 6. The MCP submits the job and returns a generation ID; it will poll automatically and post the image URL when rendering completes (typically 30–90 seconds). 7. Check the generation's status anytime by asking '@Luma Labs get generation <id>'. 8. Remember: each image or video costs credits from your Luma balance, and jobs queue if you hit rate limits.
What teammates see: by default, memories from Luma Labs are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Product Hero Image
@Luma Labs generate an image: a sleek wireless earbud case on a marble surface, soft studio lighting, 16:9 aspect ratio, photorealistic style
Social Video Clip
@Luma Labs generate a video: camera slowly orbits a glowing neon sign that reads 'OPEN', dark alley background, 5 seconds, cinematic mood
Edit Existing Footage
@Luma Labs edit video <file_id>: change the sky to a dramatic sunset and add light rain, keep everything else the same
Layer Extraction
@Luma Labs extract image layers from <file_id> at 1024x1024 resolution, then share the layer URLs
Check Generation Status
@Luma Labs get generation <generation_id> and let me know if it's completed or still processing
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@lumalabs generate a 5-second video of a golden retriever running through a sunlit meadow, camera tracking from the side
I've submitted your video generation request to Luma Ray 3.2. The job is queued with generation ID gen_abc123xyz. Video generation typically takes 2-4 minutes depending on queue depth. I'll check back in 90 seconds to see if your clip is ready — you can also monitor progress by asking me to check the generation status. Once complete, you'll receive a download URL for the rendered MP4.
Video generation is asynchronous and billed per job. The MCP returns a generation ID immediately; the AI must poll GET_GENERATION to retrieve the final video URL. Expect 2-5 minute turnaround under normal load. Prompt quality directly affects output fidelity.
@lumalabs check the status of generation gen_abc123xyz and show me the result if it's done
Your video generation completed successfully 47 seconds ago. The output is a 5-second 1080p MP4 available at https://cdn.luma.ai/outputs/gen_abc123xyz.mp4 (link expires in 7 days). The job consumed 1 credit and took 3m 12s to render. State is 'completed' with no moderation flags.
Polling GET_GENERATION is the only way to retrieve finished assets. The MCP does not push webhooks through this interface. Output URLs expire after 7 days; download or re-host critical assets. Moderation state may block delivery if content violates Luma's policy.
@lumalabs extract foreground layers from the uploaded product photo file_xyz789 at high resolution for compositing
I've queued an image layer-extraction job (generation ID gen_layer456) for file_xyz789 at 2048px resolution. Luma will separate the foreground subject from the background and return both as transparent PNGs. Flat pricing applies regardless of layer count. The job is processing now; typical extraction takes 30-90 seconds. I'll poll the status shortly and provide download links when ready.
Layer extraction is a paid operation billed per generation at the chosen resolution tier. The MCP requires a valid file ID from a prior upload. Extraction quality depends on subject contrast and edge definition in the source image. Use GET_GENERATION to retrieve the layer URLs.
Use-case deep-dives
When Luma Labs speeds up marketing asset cycles
A 3-person SaaS marketing team ships feature demos every sprint and needs video variants fast. Luma Labs wins here because the async video-generation and edit tools let you queue multiple aspect ratios or style tweaks in one batch, then pull results when ready—no blocking on render time. The API-key auth keeps credentials out of shared Slack threads. The catch: each generation is a paid call, so if your team runs 40+ variants per month, budget the per-job cost before committing. If you're under 20 renders and need same-day turnaround, Luma's async pattern fits the standup-to-publish cadence. Start with Generate Video for net-new clips and Edit Video for quick reskins of existing footage.
Luma for high-volume product photography at scale
A 6-person e-commerce brand launches 15 SKUs monthly and needs hero images in multiple backgrounds. Luma's Generate Image and Edit Image tools handle the volume: queue all variants at once, monitor with Get Generation, and soft-delete drafts with Delete File when the client picks winners. The layer-extraction tool is useful if you need transparent cutouts for compositing later. This setup works when your catalog refresh is predictable and you can batch requests weekly. It breaks down if you need real-time previews during a live photoshoot—async jobs take seconds to minutes, not milliseconds. For teams shipping 50+ images per month with a 24-hour approval window, Luma's pricing and throughput beat manual Photoshop pipelines.
When Luma doesn't fit support ticket workflows
A 2-person customer success team wants to auto-generate personalized onboarding videos for each new enterprise account. Luma Labs is the wrong call here. The async generation model means you can't inline a video in a live chat or ticket response—you'd queue the job, wait for completion, then send the link in a follow-up message. That latency kills the support flow. The 11-tool surface is also overkill; you'd use Generate Video and Get Generation, ignoring the rest. If your onboarding videos are templated and sent in a scheduled email drip 24 hours post-signup, Luma works. But for reactive, ticket-driven support, you need synchronous screen-recording tools or pre-rendered libraries, not paid async generation.
Frequently asked
What does the Luma Labs MCP do in Switchy?
It lets your team generate and edit AI videos and images directly from Switchy using Luma's Ray 3.2 model. You can start paid generation jobs, monitor their status, extract image layers, and manage uploaded files. All operations are asynchronous—you submit a job, then poll for results using the generation ID.
Do I need a Luma Labs account to use this MCP?
Yes. You need an active Luma Labs account and an API key from their dashboard. The MCP uses API_KEY authentication, so whoever connects it must paste their key into Switchy's settings. Each generation job bills against your Luma account at their published per-job pricing.
Can the Luma MCP generate videos from text prompts?
Yes. The Generate Video tool submits a Ray 3.2 video generation job from a text prompt. It returns a generation ID immediately; you then use Get Generation to poll until the video renders and Luma returns the output URL. The same pattern applies to image generation and editing.
How is this different from using Luma's web app?
The MCP exposes Luma's API inside Switchy's shared workspace, so your team can trigger generations from chat or workflows without switching tabs. You lose the web app's preview UI and manual tweaking, but gain programmatic access and the ability to chain Luma jobs with other MCPs.
Who on my team should connect the Luma MCP?
Whoever owns your Luma Labs billing. The API key ties directly to a Luma account, and every generation charges that account. If multiple people need access, either share one connection or have each person connect their own key and track usage separately.