Free Youtube Video Editor

0. First Contact

When the user opens this skill or sends their first message, greet them immediately:

🎵 Welcome! I can youtube video editor for you. Share a video file or tell me your idea!

Try saying:

• "add a fade-in transition"
• "make it look cinematic"
• "speed up by 2x"

IMPORTANT: Always greet the user proactively on first contact. Let them know you're setting up while connecting. Always greet the user proactively on first contact.

Auto-Setup

When the user first interacts, set up the connection:

1. Check token: If NEMO_TOKEN env var is set, use it. Otherwise:
2. Read or generate Client-ID:
   • Read ~/.config/nemovideo/client_id if it exists
   • Otherwise generate a UUID, save it to ~/.config/nemovideo/client_id
3. Acquire anonymous token:

   curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
   

   Store the returned token as NEMO_TOKEN for this session. You get 100 free credits.
4. Create a session (§3.0) so you're ready to work immediately.

Let the user know briefly: "Setting things up… ready!" then proceed with their request.

Edit YouTube Videos by Just Describing What You Want

Most video editing tools assume you already know what a B-roll cutaway or a J-cut is. The free-youtube-video-editor skill flips that assumption entirely. You upload your raw footage and tell the AI what the final video should look like — 'remove the first 30 seconds where I'm fumbling with the mic' or 'cut straight to where I start the demo' — and the system handles the rest.

Under the hood, ClawHub's OpenClaw agent interprets your natural-language instructions and maps them to precise edit operations: trimming, splitting, reordering, and stitching segments back together in the sequence you described. The agent maintains context across the conversation, so you can refine iteratively — asking for a tighter cut here, a longer pause there — without starting over from scratch each time.

This skill is specifically designed around the YouTube production workflow. That means the output is formatted for direct upload: correct aspect ratios, clean in/out points, and no re-encoding artifacts that tank quality on YouTube's compression pipeline. Whether you're cleaning up a 45-minute tutorial or punching up a 90-second product showcase, the editing conversation stays focused on your content, not on software menus.

Environment Variables

If NEMO_TOKEN is not set, get one (requires X-Client-Id header):

# Generate or read persisted Client-Id
CLIENT_ID="${NEMO_CLIENT_ID:-$(cat ~/.config/nemovideo/client_id 2>/dev/null)}"
if [ -z "$CLIENT_ID" ]; then
  CLIENT_ID=$(uuidgen 2>/dev/null || echo "client-$(date +%s)-$RANDOM")
  mkdir -p ~/.config/nemovideo & echo "$CLIENT_ID" > ~/.config/nemovideo/client_id
fi
curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
# → {"code":0,"data":{"token":"nmv_usr_xxx","credits":100,...}}

Save token as NEMO_TOKEN, CLIENT_ID as NEMO_CLIENT_ID. Anonymous: 1 token per client per 7 days; token expires in 7 days and can be revoked at any time via Settings → API Tokens on nemovideo.com. If your token expires, request a new one with the same X-Client-Id.

Local persistence: This skill writes ~/.config/nemovideo/client_id to persist the Client-Id across sessions. This avoids generating a new ID on every request, which would hit the per-IP rate limit quickly (default 10 tokens per 7 days per IP). The file contains only a UUID — no credentials are stored locally.

2. Routing Incoming Requests to the Correct Endpoint

Use the table below to determine which endpoint handles each type of user request.

3. Primary Workflow Sequences

$API = ${NEMO_API_URL:-https://mega-api-prod.nemovideo.ai}, $TOKEN = ${NEMO_TOKEN}, $WEB = ${NEMO_WEB_URL:-https://nemovideo.com}.

Skill attribution variables — do NOT hardcode:

• $SKILL_NAME = this file's YAML frontmatter name
• $SKILL_VERSION = this file's YAML frontmatter version
• $SKILL_SOURCE = detect at runtime using the first match:
  1. Env SKILL_SOURCE if set
  2. If this file's path contains a known platform directory (e.g. ~/.clawhub/ → clawhub, ~/.cursor/skills/ → cursor)
  3. Fallback: unknown

CRITICAL: ALL API requests (including render/export/upload/state/credits) MUST include these headers. Missing them will cause export to fail with 402.

X-Skill-Source: $SKILL_NAME
X-Skill-Version: $SKILL_VERSION
X-Skill-Platform: $SKILL_SOURCE

3.0 Establishing a New Session

curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" \
  -d '{"task_name":"project","language":"<lang>"}'
# → {"code":0,"data":{"task_id":"...","session_id":"..."}}

Before any editing actions can occur, a session must be initialized with the backend. This session ID ties all subsequent requests together for the duration of the editing task.

Open in browser: After creating a session, give the user a link to view/edit the task in NemoVideo: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

3.1 Delivering Messages Through the SSE Channel

curl -s -X POST "https://mega-api-prod.nemovideo.ai/run_sse" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" --max-time 900 \
  -d '{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}'

All conversational messages to the editing backend are transmitted as Server-Sent Events over a persistent connection.

SSE Handling

Typical durations: text 5-15s, video generation 100-300s, editing 10-30s.

Timeout: 10 min heartbeats-only → assume timeout. Never re-send during generation (duplicates + double-charge).

Ignore trailing "I encountered a temporary issue" if prior responses were normal.

Silent Response Fallback (CRITICAL)

Approximately 30% of editing operations complete without returning any text in the response body. When this occurs: (1) do not treat the absence of text as an error or failure, (2) poll the session state endpoint to confirm the operation status, (3) surface a neutral status message to the user such as 'Your edit is being processed,' and (4) proceed to the export step once the state confirms completion.

Two-stage generation: After delivering the raw edited video, the backend automatically initiates a second processing stage that layers in background music and generates a title overlay. These two stages are sequential and distinct — do not attempt to trigger the second stage manually or treat the intermediate raw output as the final deliverable.

3.2 Handling File Uploads

File upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -F "files=@/path/to/file"

URL upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"urls":["<url>"],"source_type":"url"}'

Use me in the path; backend resolves user from token.

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

The upload endpoint accepts video files submitted directly by the user and returns a file reference ID for use in subsequent editing requests.

3.3 Checking Available Credits

curl -s "https://mega-api-prod.nemovideo.ai/api/credits/balance/simple" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"
# → {"code":0,"data":{"available":XXX,"frozen":XX,"total":XXX}}

Query the credits endpoint before initiating any edit operation to confirm the user has a sufficient balance to proceed.

3.4 Retrieving Current Session State

curl -s "https://mega-api-prod.nemovideo.ai/api/state/nemo_agent/me/<sid>/latest" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Use me for user in path; backend resolves from token. Key fields: data.state.draft, data.state.video_infos, data.state.canvas_config, data.state.generated_media.

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

Draft ready for export when draft.t exists with at least one track with non-empty sg.

Track summary format:

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

3.5 Triggering Export and Delivering the Final File

Export does NOT cost credits. Only generation/editing consumes credits.

Exporting the finished clip does not deduct any credits from the user's balance. The export sequence proceeds as follows: (a) confirm the session state shows a completed edit, (b) call the export endpoint with the active session ID, (c) poll for the export job status until it returns a completed state, (d) retrieve the download URL from the completed export response, and (e) present that URL to the user as their ready-to-upload file.

b) Submit: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}'

Note: sessionId is camelCase (exception). On failure → new id, retry once.

c) Poll (every 30s, max 10 polls): curl -s "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda/<id>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Status at top-level status: pending → processing → completed / failed. Download URL at output.url.

d) Download from output.url → send to user. Fallback: https://mega-api-prod.nemovideo.ai/api/render/proxy/<id>/download.

e) When delivering the video, always also give the task detail link: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

Progress messages: start "⏳ Rendering ~30s" → "⏳ 50%" → "✅ Video ready!" + file + task detail link.

3.6 Recovering from an SSE Disconnection

If the SSE stream drops unexpectedly, follow these recovery steps: (1) immediately attempt to re-establish the SSE connection using the existing session ID rather than creating a new session, (2) query the session state endpoint to determine how much of the previous operation completed before the disconnect, (3) if the operation was already finished, proceed directly to export without replaying the edit request, (4) if the operation was still in progress, resume listening on the reconnected stream and await the completion event, and (5) notify the user of the brief interruption only if the reconnection attempt exceeds a reasonable timeout threshold.

4. Translating Backend GUI References for the User

The backend is built around a graphical interface and will occasionally reference UI elements in its responses — never pass those GUI-specific instructions through to the user verbatim.

Keep content descriptions. Strip GUI actions.

5. Recommended Conversational Patterns

• Confirm what the user wants to accomplish before initiating any API call, especially for destructive operations like trimming or cutting. • After each editing step completes, summarize what changed in plain language rather than exposing raw response payloads. • When a silent response occurs, bridge the gap with a brief progress acknowledgment so the user does not assume something went wrong. • If the user requests an action that would exceed their credit balance, explain the limitation clearly and offer to check remaining credits before proceeding. • Always present the final export URL as a direct, clickable link accompanied by a short confirmation that the file is ready to upload.

6. Known Constraints and Limitations

• Only one active editing session per user is supported at a time; starting a new session will not automatically close a previous one. • The two-stage post-processing pipeline for BGM and title overlays cannot be skipped or reordered by the AI layer. • Export operations are available only after the session state reflects a fully completed edit — calling export prematurely will return an error. • File uploads are subject to size and format restrictions defined by the upload endpoint; the AI layer cannot override these constraints. • Credit balances are read-only from the AI perspective — the skill can check and display them but cannot add, adjust, or refund credits.

7. Error Recognition and Response Guidance

The table below maps common HTTP error codes returned by the API to their likely causes and the recommended recovery action for each.

Common: no video → generate first; render fail → retry new id; SSE timeout → §3.6; silent edit → §3.1 fallback.

8. API Version Compatibility and Required Token Scopes

Always verify that the API version specified in the request header matches the version this skill was certified against before making any calls. Token scopes must include read access for session state and credits endpoints, and write access for the message, upload, and export endpoints. Attempting to call an endpoint without the appropriate scope will result in a 403 response regardless of token validity. If a version mismatch is detected, surface a clear notice to the user rather than proceeding with potentially incompatible calls.