Getting Started

Session: POST https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent with Bearer auth and body {"task_name":"project"}. Keep the returned session_id for all operations.

Let the user know with a brief "Ready!" when setup is complete. Don't expose tokens or raw API output.

Resize Any Video in Seconds, Not Hours

Getting video dimensions wrong can derail an entire project — stretched thumbnails, letterboxed ads, or footage that simply won't upload to a platform because the resolution is off. This skill takes the frustration out of resizing by generating ready-to-run ffmpeg commands specifically tuned to your video's source dimensions and your target output.

Whether you need to downscale a 4K recording to 1080p for faster streaming, crop a widescreen clip into a square format for social media, or pad a vertical video to fit a 16:9 canvas without distortion, this skill handles the logic for you. Just describe what you have and what you need — dimensions, aspect ratio, padding color, scaling algorithm — and you'll get a clean, copy-paste command in seconds.

This is built for content creators juggling multiple platforms, developers automating video pipelines, and editors who know what they want but don't want to memorize ffmpeg's filter syntax every time. No more Stack Overflow rabbit holes. Just describe your resize goal and get the exact command that does it right.

Routing Your Resize Requests

When you submit a resize, crop, or scale request, the skill parses your target resolution, aspect ratio, and padding preferences — then routes the job to the appropriate FFmpeg filter chain pipeline automatically.

FFmpeg Cloud API Reference

All video scaling operations run on a cloud-hosted FFmpeg backend using libswscale and hardware-accelerated filter graphs, so your local machine never touches the heavy lifting. Jobs are queued per session, with vf scale, pad, and crop filters composed dynamically based on your input parameters.

Skill attribution — read from this file's YAML frontmatter at runtime:

• X-Skill-Source: ffmpeg-resize-video
• X-Skill-Version: from frontmatter version
• X-Skill-Platform: detect from install path (~/.clawhub/ → clawhub, ~/.cursor/skills/ → cursor, else unknown)

All requests must include: Authorization: Bearer <NEMO_TOKEN>, X-Skill-Source, X-Skill-Version, X-Skill-Platform. Missing attribution headers will cause export to fail with 402.

API base: https://mega-api-prod.nemovideo.ai

Create session: POST /api/tasks/me/with-session/nemo_agent — body {"task_name":"project","language":"<lang>"} — returns task_id, session_id.

Send message (SSE): POST /run_sse — body {"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}} with Accept: text/event-stream. Max timeout: 15 minutes.

Upload: POST /api/upload-video/nemo_agent/me/<sid> — file: multipart -F "files=@/path", or URL: {"urls":["<url>"],"source_type":"url"}

Credits: GET /api/credits/balance/simple — returns available, frozen, total

Session state: GET /api/state/nemo_agent/me/<sid>/latest — key fields: data.state.draft, data.state.video_infos, data.state.generated_media

Export (free, no credits): POST /api/render/proxy/lambda — body {"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}. Poll GET /api/render/proxy/lambda/<id> every 30s until status = completed. Download URL at output.url.

Supported formats: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

SSE Event Handling

~30% of editing operations return no text in the SSE stream. When this happens: poll session state to verify the edit was applied, then summarize changes to the user.

Backend Response Translation

The backend assumes a GUI exists. Translate these into API actions:

Draft field mapping: t=tracks, tt=track type (0=video, 1=audio, 7=text), sg=segments, d=duration(ms), m=metadata.

Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)

Error Handling

FAQ

Will resizing reduce my video quality? Downscaling (reducing resolution) generally preserves visual quality well, especially with high-quality scaling filters like lanczos. Upscaling, however, can introduce softness since you're adding pixels that weren't there. This skill will recommend the right filter for your use case.

Can I resize without changing the aspect ratio? Absolutely. You can scale to a target width or height and let ffmpeg calculate the other dimension automatically, keeping your aspect ratio intact. Just specify one dimension and the skill will generate the correct command.

What if my target platform requires a specific resolution and aspect ratio? Describe the platform (e.g., YouTube Shorts, LinkedIn, Twitter) and this skill will generate a command that handles both the resize and any necessary padding or cropping to match the platform's specs.

Does this work for batch resizing multiple files? Yes — ask for a batch-compatible version of the command and the skill will generate a shell loop or ffmpeg batch pattern you can run across an entire folder of videos.

Common Workflows

Downscaling for Web Delivery: One of the most frequent use cases is taking high-resolution source footage — often 4K or 2.7K — and resizing it to 1080p or 720p for faster uploads and smoother playback. This skill generates commands that use the scale filter with a high-quality algorithm to keep the output sharp.

Social Media Format Conversion: Different platforms demand different dimensions. Converting a 16:9 widescreen video to a 1:1 square for Instagram, or to a 9:16 vertical for TikTok and Reels, requires both cropping and scaling logic. This skill generates the crop and scale filter chain in the correct order so your subject stays centered and nothing gets accidentally cut off.

Padding to a Fixed Canvas: Sometimes you need to fit a video into a fixed resolution without cropping — think letterboxing or pillarboxing. Describe your source dimensions and target canvas size, and the skill generates a scale + pad filter command with your preferred background color.

Pipeline Automation: Developers building automated video processing pipelines can ask for parameterized command templates they can slot into scripts, making ffmpeg-resize-video operations repeatable and consistent across hundreds of files.