OpenClaw x Unifically: Add AI Media to Your Agent

OpenClaw is one of the most exciting open-source projects of 2026 — a free, MIT-licensed, autonomous AI agent that runs on your own machine and lives inside the chat apps you already use (WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Matrix). Out of the box it can browse the web, run shell commands, manage your calendar, write files, and even build its own Skills on the fly. The one thing it cannot do natively is generate media — that is exactly the gap Unifically fills.

TL;DR: Install OpenClaw on your own computer, drop the copy-paste SKILL.md from Step 5 below into its Skills folder, and your agent gains video, image, music, and voice generation through Unifically's unified /v1/tasks API. From any chat — WhatsApp, Telegram, Discord — you can text "make me a Veo clip of a dolphin surfing at sunset" and get the rendered MP4 back in seconds.

What is OpenClaw?

OpenClaw is a free, open-source autonomous AI agent created by Peter Steinberger and a fast-growing open-source community. It is built primarily in TypeScript, licensed under MIT, and runs on macOS, Linux, Windows, or even a Raspberry Pi.

A few things make it different from yet another chatbot:

• It runs on your hardware. Your context, memory, and Skills never leave your machine.
• It uses messaging apps as its UI. No new app to install — chat with it on WhatsApp, Telegram, Discord, Slack, Signal, iMessage, or Matrix via plugins.
• It is provider-agnostic. Run it on Anthropic, OpenAI, a local model via Ollama, or any compatible gateway.
• It has persistent memory. It remembers your preferences, projects, and tone of voice across restarts.
• It is proactive. A heartbeat fires every 30 to 60 minutes, so it can run scheduled tasks and reach out when something needs your attention.
• It is extensible via Skills. Skills are TypeScript modules that wrap APIs and tools. The agent can write, test, and hot-reload its own Skills — which is exactly how we will add Unifically.

For a deeper look, see our OpenClaw overview page.

What is Unifically?

Unifically is a single REST API that exposes 80+ generative AI models — video, image, audio — behind one authentication scheme and two endpoints:

POST https://api.unifically.com/v1/tasks
GET  https://api.unifically.com/v1/tasks/:task_id

The same shape works for Veo 3.1, Kling 3.0 Omni, Suno music, ElevenLabs TTS, Nano Banana Pro, GPT Image 2, Topaz upscalers, and dozens more. You pay per generation with no subscriptions; live rates are on the pricing page. The full developer reference is at docs.unifically.com, and there is an llms-full.txt you can drop straight into any LLM context — including OpenClaw.

Why OpenClaw + Unifically is a perfect pairing

OpenClaw is the brain and chat interface. Unifically is the creative toolbox.

Capability	OpenClaw native	Add Unifically
Reasoning, planning, memory	Yes	—
Browser, files, shell	Yes	—
Photoreal image generation	No	Yes (Nano Banana Pro, GPT Image 2, Flux.2)
Cinematic video generation	No	Yes (Veo 3.1, Kling 3.0, Hailuo)
Music & vocals	No	Yes (Suno)
Voice cloning & TTS	No	Yes (ElevenLabs)
Image / video upscaling	No	Yes (Topaz Labs)

The result: a single chat thread that can plan your week and render you a Veo cinematic for your podcast intro, in the same conversation.

Prerequisites

1. Node.js 22.14+ or Node 24 installed (the OpenClaw one-liner can install Node for you on macOS/Linux).
2. An LLM provider key — Anthropic, OpenAI, or a local/proxy setup. OpenClaw is provider-agnostic.
3. A Unifically API key — grab one from the API keys page. Sign-up is free; you only pay per generation.

No Docker, no cloud account, no credit card if you stick to the free Unifically credits at sign-up.

Step 1 — Install OpenClaw

Pick the install path that fits how you like to set up new tools.

One-liner (macOS & Linux, fastest):

curl -fsSL https://openclaw.ai/install.sh | bash

npm (if you already have Node 22.14+ or 24):

npm i -g openclaw
openclaw onboard

From source:

git clone https://github.com/openclaw/openclaw.git
cd openclaw && corepack enable && pnpm install
pnpm openclaw onboard

openclaw onboard walks you through picking your LLM provider, choosing which messaging channels to enable, and bringing the agent online. You can switch release channels later with openclaw update --channel dev or openclaw update --channel stable. Full reference: docs.openclaw.ai.

Step 2 — Get your Unifically API key

Open the Unifically API keys page, sign in, and click Create key. Copy the value — you only see it once — and export it as an environment variable so OpenClaw and any Skill you write can read it without you ever pasting it back into chat:

export UNIFICALLY_API_KEY="sk-uni-..."

On Windows PowerShell:

$Env:UNIFICALLY_API_KEY = "sk-uni-..."

For persistence across restarts, drop it into the env file your openclaw onboard step created or your shell rc file.

Step 3 — The Unifically API in 60 seconds

The whole API is two calls. Once you have these in your head, every model in the catalog works the same way.

Create a task:

curl -X POST https://api.unifically.com/v1/tasks \
  -H "Authorization: Bearer $UNIFICALLY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/veo-3.1-fast",
    "input": { "prompt": "a dolphin surfing at sunset, cinematic" }
  }'

The response gives you a task_id:

{
  "code": 200,
  "success": true,
  "data": { "task_id": "abc123def456", "status": "pending" }
}

Poll for the result:

curl https://api.unifically.com/v1/tasks/abc123def456 \
  -H "Authorization: Bearer $UNIFICALLY_API_KEY"

When status becomes completed, the response includes an output object with one of video_url, image_url, or audio_url:

{
  "code": 200,
  "success": true,
  "data": {
    "task_id": "abc123def456",
    "status": "completed",
    "output": { "video_url": "https://cdn.unifically.com/outputs/abc123.mp4" }
  }
}

A few extras worth knowing:

• callback_url — pass it at the top level and Unifically will POST the result to your URL when the task finishes. No polling required.
• dry_run: true — preview the cost of a request without actually generating anything. Handy when an OpenClaw Skill needs to ask the user "this will cost $0.30, proceed?" before spending money.
• /account — GET https://api.unifically.com/account returns your remaining USD balance.

Step 4 — The lazy path: ask OpenClaw to build the Skill for you

OpenClaw can write its own Skills, and Unifically publishes a full machine-readable spec at llms-full.txt. Open any chat where your OpenClaw is listening and send a message like:

Build me a Skill called unifically that calls the Unifically API at https://api.unifically.com/v1/tasks to generate video, images, and audio. Read the full spec at https://docs.unifically.com/llms-full.txt. The API key is in UNIFICALLY_API_KEY. Expose three actions: generate_video, generate_image, generate_audio. Each one should create a task, poll until it's done, and return the output URL. Test it with a 4-second Veo 3.1 Fast clip of a cat walking on the beach, then hot-reload.

OpenClaw will read the docs, write the Skill in TypeScript, run a test, fix any errors itself, and reload. Within a minute or two it will reply with a link to a finished cat video. From there, every future media-generation message is a one-liner.

If you would rather hand OpenClaw a finished, hand-tuned spec, the next section gives you a complete drop-in SKILL.md you can paste in 30 seconds.

Step 5 — Copy-paste this SKILL.md into OpenClaw

If you would rather not write code or wait for OpenClaw to author its own Skill, here is a complete drop-in SKILL.md that turns any OpenClaw instance into a Unifically-powered media studio.

Install in 60 seconds:

1. Find your OpenClaw skills directory (default is ~/.openclaw/skills/ on macOS/Linux, %USERPROFILE%\.openclaw\skills\ on Windows). The exact path is shown at the end of openclaw onboard.
2. Create a new folder called unifically inside it.
3. Save the markdown below as unifically/SKILL.md.
4. Make sure UNIFICALLY_API_KEY is set in your environment.
5. Restart OpenClaw or run openclaw skills reload.

From the next message onward, your agent knows every model ID, every parameter, and every natural-language trigger.

---
name: unifically
description: >-
  Generate AI video, images, music, voice, and upscaled media via Unifically's
  unified /v1/tasks API. Activate whenever the user asks to create, generate,
  render, make, draw, paint, animate, voice, sing, narrate, dub, upscale,
  remaster, or restyle any visual or audio asset. Covers Veo 3.1, Kling 3.0,
  SeeDance, Hailuo, Suno, ElevenLabs, Nano Banana Pro, GPT Image 2, Flux.2,
  Qwen Image, Topaz Labs, and 80+ more models.
risk: paid-api
auth: env:UNIFICALLY_API_KEY
docs: https://docs.unifically.com/llms-full.txt
---

# Unifically — One API for Every Generative AI Model

## Overview

Unifically exposes 80+ generative AI models behind a single REST endpoint:

- POST https://api.unifically.com/v1/tasks - create a generation task
- GET  https://api.unifically.com/v1/tasks/{task_id} - poll status / fetch result
- GET  https://api.unifically.com/account - check remaining USD balance

Authentication is `Authorization: Bearer $UNIFICALLY_API_KEY`. The API key
must NEVER appear in chat output - read it from the environment variable.

## When to Activate

Activate this skill when the user's message contains intent like:

- Video: "make / generate / render a video / clip / cinematic / animation"
- Image: "create / draw / paint / mock up / poster / thumbnail / icon / logo"
- Music: "write a song / track / podcast intro / jingle"
- Voice: "voice / narrate / read / dub / TTS this"
- Edit / Upscale: "upscale / enhance / 4K / restore / remaster / clean up"

If the user does NOT specify a model, pick a sane default from the table
below and tell them which one you chose and what it costs.

## Two-Call Pattern (Universal)

Every generation follows the same shape.

### 1. Create the task

curl -X POST https://api.unifically.com/v1/tasks \
  -H "Authorization: Bearer $UNIFICALLY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<provider/model-id>",
    "input": { ...model-specific parameters... }
  }'

Response:
{ "success": true, "data": { "task_id": "abc123", "status": "pending" } }

### 2. Poll until completed

curl https://api.unifically.com/v1/tasks/abc123 \
  -H "Authorization: Bearer $UNIFICALLY_API_KEY"

Statuses: `pending` -> `processing` -> `completed` | `failed`. When
`completed`, the response contains `data.output` with one of:

- video_url (mp4)
- image_url (png/jpg)
- audio_url (mp3/wav)

Use exponential backoff: start at 2s, multiply by 1.5, cap at 10s, give
up after 10 minutes.

### Webhooks (recommended for long jobs)

Add `"callback_url": "https://your-host/webhook"` at the TOP level of the
create payload (NOT inside `input`). Unifically will POST the same
`{task_id, status, data}` shape to that URL when the task finishes.

### Dry-run for cost preview

Add `"dry_run": true` to any create call. Response returns
`{ data: { cost: 0.30 } }` with no task created and no balance deducted.
Use this BEFORE every paid generation > $0.10 to confirm the price with
the user.

## Default Model Picker

If the user does not specify a model, pick by intent and budget:

| Intent                              | Default model                    | Approx. price   |
| ----------------------------------- | -------------------------------- | --------------- |
| Cinematic video, audio, 4-8s        | google/veo-3.1-fast              | $0.30 / video   |
| Cheapest video draft                | google/veo-3.1-lite-relaxed      | $0.075 / video  |
| Reference-driven character video    | kuaishou/kling-3.0-omni-video    | ~$0.06 / sec    |
| Photoreal image, strong text        | google/nano-banana-pro           | $0.06 / image   |
| Cheap image draft                   | google/nano-banana               | $0.03 / image   |
| OpenAI image (logos, mockups)       | openai/gpt-image-2               | $0.03-$0.06     |
| Open-ecosystem image                | black-forest-labs/flux.2-pro     | per MP rate     |
| Full song with vocals               | suno-ai/music                    | $0.06 / song    |
| Sound effect                        | suno-ai/sound                    | $0.01 / shot    |
| Text-to-speech                      | elevenlabs/text-to-speech        | per-char rate   |
| Image upscale to 4K                 | topaz-labs/image-upscale         | per-image rate  |
| Video upscale to 4K                 | topaz-labs/video-upscale         | $0.06 / sec     |

Always announce the chosen model and price before spending.

## Model Catalog (curated subset)

### Video models

- google/veo-3.1-lite / veo-3.1-lite-relaxed / veo-3.1-fast / veo-3.1-fast-relaxed / veo-3.1-quality - Google Veo 3.1.
  Params: prompt, aspect_ratio (16:9|9:16), duration (4|6|8s),
  start_image_url, end_image_url, OR reference_image_urls[] (Fast only), optional voice (Fast only).
- google/veo-3.1-extend - extend a completed Veo task. Requires task_id.
- google/veo-3.1-upscale-1080p / veo-3.1-upscale-4k - upscale a finished task.
- kuaishou/kling-3.0-video, kling-2.6-video, kling-2.5-turbo-video,
  kling-2.1-video, kling-2.1-master-video. Params: prompt, duration,
  aspect_ratio, optional image_url (image-to-video).
- kuaishou/kling-3.0-omni-video / kling-3.0-omni-video-edit -
  reference-driven and edit modes.
- kuaishou/kling-3.0-motion-control / kling-2.6-motion-control - drive a
  reference character with a motion video.
- bytedance/seedance-2.0-pro / seedance-2.0-fast / seedance-1.5-pro.
- hailuo/minimax-2.3 / minimax-2.3-fast / minimax-2.0 - MiniMax Hailuo.
- xai/grok-imagine-video / grok-imagine-video-edit.
- topaz-labs/video-upscale - Params: video_url, target_resolution.

### Image models

- google/nano-banana-pro - Nano Banana Pro (Gemini 3 Pro Image).
  Params: prompt, resolution (1k|2k), aspect_ratio, optional image_urls[] for editing.
- google/nano-banana / google/nano-banana-2 - older / standard tiers.
  Nano Banana 2 supports resolution (1k|2k|4k) for $0.03 / $0.05 / $0.06.
- openai/gpt-image-2 - Params: prompt, resolution (1k|2k|4k), aspect_ratio (1:1|2:3|3:2),
  optional image_urls[] for edits. Tiers: $0.03 / $0.05 / $0.06.
- black-forest-labs/flux.2-pro / flux.2-flex / flux.2-max,
  flux.2-klein-4b / flux.2-klein-9b.
- kuaishou/kling-3.0-image / kling-3.0-omni-image / kling-2.1-image /
  kling-o1-image.
- alibaba/qwen-image-2.0-pro / qwen-image-2.0 / qwen-image-max /
  qwen-image-plus / qwen-image / z-image-turbo.
- alibaba/wan-2.7-pro-image (up to 4K) / wan-2.7-image / wan-2.6-image.
- xai/grok-imagine-image.
- topaz-labs/image-upscale.

### Audio models

- suno-ai/music - generate full songs. Params: prompt (style/lyrics),
  instrumental (bool), mv (model version: V5_5 Fenix, V5 Crow, V4_5PLUS, etc).
- suno-ai/cover / extend / add-vocals / add-instrumental /
  stems / stems-all / lyrics / wav / sound / voice / custom-model.
- elevenlabs/text-to-speech - Params: text, voice_id, model_id,
  voice_settings.
- elevenlabs/text-to-dialogue - multi-voice scripted dialogue.
- elevenlabs/sound-effect - Params: text, duration_seconds.
- elevenlabs/voice-isolation - strip background noise.
- elevenlabs/speech-to-text.

The full list is at https://docs.unifically.com/llms-full.txt - when in
doubt, fetch and grep that file before answering.

## Output Handling

- Video: download the video_url to a temp file, send as a video attachment.
  Caption with the model name and cost.
- Image: send as image attachment, caption with model + cost.
- Audio: send as voice/audio attachment.
- Always offer a 1-line follow-up: "Want a 4K upscale? An extension? A
  variant with different lighting?" - those are the highest-margin
  follow-ups and the user usually says yes.

## Error Handling

- HTTP 401 -> UNIFICALLY_API_KEY is missing or wrong. Tell the user to
  re-export it. Never echo the key.
- HTTP 402 -> balance too low. Tell the user the current balance from
  GET /account and link to https://unifically.com/payments.
- HTTP 422 -> bad input. Read error.message, fix the parameter shape,
  retry once. Never blindly retry.
- status: failed with error.message containing "policy" or "moderation"
  -> tell the user the prompt was rejected and offer a rewrite.
- Network or timeout -> retry once with a fresh task_id. Do not double-bill.

## Best Practices

- Always run dry_run: true before any generation expected to cost more
  than $0.10. Quote the cost. Wait for confirmation.
- Cache outputs by sha256(prompt + model + params) for 7 days. If the
  user asks the same thing twice, return the cached URL and skip billing.
- Default to 16:9 for video unless the user mentions phone, vertical,
  TikTok, Reels, Shorts, or Stories - then 9:16.
- Default to 4-second video duration. Up to 8s only if the user asks
  for "longer" or specifies a duration.
- When a user asks to "remix" or "edit" a previously generated asset,
  use the *-edit or *-extend variant of the same family rather than
  starting fresh.
- Do not poll faster than 2-second intervals. Do not poll past 10 minutes.
- Do not paste API keys, balances, or task IDs into chat unless asked.
- Do not expose internal CDN URLs in the chat caption - just attach the
  media file.

## Resources

- Full machine-readable docs: https://docs.unifically.com/llms-full.txt
- API keys: https://unifically.com/api-keys
- Pricing: https://unifically.com/pricing
- Models catalog: https://unifically.com/models
- Top-up balance: https://unifically.com/payments

That's a complete, self-contained Skill. OpenClaw will read it on next reload, and from that point on it knows every model ID, every parameter, every natural-language trigger, and every cost-control habit you would want a sensible agent to have.

If you would rather see the actual TypeScript implementation that this SKILL.md describes, the next section is for you.

Step 6 — The "I want to see the code" path

Here is a minimal but production-shaped Skill you can drop into your OpenClaw Skills directory. It follows the same patterns OpenClaw will produce on its own, just hand-written for clarity.

const BASE = "https://api.unifically.com";
const API_KEY = process.env.UNIFICALLY_API_KEY!;

type CreateResp = {
  success: boolean;
  data: { task_id: string; status: string };
};

type StatusResp = {
  success: boolean;
  data: {
    task_id: string;
    status: "pending" | "processing" | "completed" | "failed";
    output?: { video_url?: string; image_url?: string; audio_url?: string };
    error?: { message: string };
  };
};

async function createTask(model: string, input: Record<string, unknown>) {
  const res = await fetch(`${BASE}/v1/tasks`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ model, input }),
  });
  if (!res.ok) throw new Error(`Unifically create failed: ${res.status}`);
  const json = (await res.json()) as CreateResp;
  return json.data.task_id;
}

async function waitForTask(taskId: string, timeoutMs = 10 * 60_000) {
  const started = Date.now();
  let delay = 2_000;
  while (Date.now() - started < timeoutMs) {
    const res = await fetch(`${BASE}/v1/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const json = (await res.json()) as StatusResp;
    const { status, output, error } = json.data;
    if (status === "completed") return output ?? {};
    if (status === "failed") throw new Error(error?.message ?? "Task failed");
    await new Promise((r) => setTimeout(r, delay));
    delay = Math.min(delay * 1.5, 10_000);
  }
  throw new Error("Timed out waiting for Unifically task");
}

export async function generateVideo(prompt: string, opts: {
  model?: string;
  duration?: 4 | 6 | 8;
  aspect_ratio?: "16:9" | "9:16";
} = {}) {
  const taskId = await createTask(opts.model ?? "google/veo-3.1-fast", {
    prompt,
    duration: opts.duration ?? 4,
    aspect_ratio: opts.aspect_ratio ?? "16:9",
  });
  const out = await waitForTask(taskId);
  return out.video_url!;
}

export async function generateImage(prompt: string, opts: {
  model?: string;
} = {}) {
  const taskId = await createTask(opts.model ?? "google/nano-banana-pro", {
    prompt,
  });
  const out = await waitForTask(taskId);
  return out.image_url!;
}

export async function generateAudio(prompt: string, opts: {
  model?: string;
  voice?: string;
} = {}) {
  const model = opts.model ?? "elevenlabs/text-to-speech";
  const input: Record<string, unknown> =
    model === "elevenlabs/text-to-speech"
      ? { text: prompt, voice_id: opts.voice ?? "21m00Tcm4TlvDq8ikWAM" }
      : { prompt };
  const taskId = await createTask(model, input);
  const out = await waitForTask(taskId);
  return out.audio_url!;
}

A few things to notice:

• One unified createTask helper. Every Unifically model uses the same envelope, so you only ever write the HTTP plumbing once.
• Backoff polling. Starts at 2s and grows to 10s — gentle enough to be polite, fast enough to feel responsive in chat.
• Sane defaults. Veo 3.1 Fast for video, Nano Banana Pro for image, ElevenLabs Rachel for voice. Override per call.
• Webhook mode is one line away. If you would rather not poll, add callback_url to the create payload and skip waitForTask.

Drop the file in the directory OpenClaw scanned during onboarding, hot-reload, and your agent now has three new tools.

Step 7 — Real prompts to try in chat

Once the Skill is loaded, this is what living with it looks like.

Video:

• "Make a 6-second Veo 3.1 clip of a dolphin surfing at sunset, 16:9, cinematic."
• "Generate a Kling 3.0 Omni clip of a samurai walking through a bamboo forest in the rain."
• "Render me a Hailuo 2.3 product shot of an espresso pour, slow motion."

Image:

• "Use Nano Banana Pro at 2K to create a poster that says 'Friday Night Live' over a neon Tokyo skyline."
• "Generate a GPT Image 2 mockup of my logo on a black hoodie, studio lighting."
• "Make me 4 Flux.2 Pro variations of a minimalist app icon, lobster mascot."

Audio:

• "Voice this paragraph in ElevenLabs Rachel: '...'"
• "Write me a 60-second Suno track for my podcast intro, lo-fi hip hop with no vocals."
• "Generate a sound effect of a heavy wooden door slamming."

OpenClaw routes the request to your Unifically Skill, polls until the task is done, and drops the resulting MP4, PNG, or MP3 back into the same chat. It even remembers your favorite voices and aspect ratios over time.

Recommended models cheatsheet

These are the models we would reach for first when wiring up a new OpenClaw Skill. Every one is available through the same /v1/tasks endpoint.

• Video — cinematic: Veo 3.1 (google/veo-3.1-fast, google/veo-3.1-quality) — Google's flagship. Native audio, 4K upscaling available.
• Video — motion & character: Kling 3.0 (kuaishou/kling-3.0-video) and Kling 3.0 Omni for reference-driven shots.
• Video — fast & cheap: SeeDance 2.0 and Minimax Hailuo for quick drafts.
• Image — realism + 4K + accurate text: Nano Banana Pro (google/nano-banana-pro).
• Image — OpenAI: GPT Image 2 (openai/gpt-image-2) — 1K / 2K / 4K tiers, multiple aspect ratios.
• Image — open ecosystem: Flux.2 (black-forest-labs/flux.2-pro).
• Music with vocals: Suno (suno-ai/music) — full songs, lyrics, stems, covers, extends.
• Voice / TTS: ElevenLabs Text-to-Speech (elevenlabs/text-to-speech) — 30+ languages, hundreds of voices.
• Upscaling: Topaz Image Upscale and Topaz Video Upscale — for cleaning up agent-generated assets before publishing.

The full catalog with current pricing is on the models page.

Tips for production

A few habits that pay off as soon as your OpenClaw starts handling real work:

• Always read keys from env vars. Never let OpenClaw paste a key into a chat. Skills can read process.env.UNIFICALLY_API_KEY directly.
• Use dry_run: true for confirmations. For anything pricier than a few cents, have OpenClaw run a dry-run first and quote the user the cost.
• Prefer webhooks over polling for long jobs. Veo Quality and Suno full-song generations can take a couple of minutes. If your OpenClaw runs on a stable host, expose a webhook endpoint and pass callback_url.
• Watch your balance. Add a tiny daily Skill that hits GET /account and pings you when balance drops below a threshold. OpenClaw's heartbeat is the perfect place for it.
• Cache outputs by hash. If the same prompt + same model gets requested twice in a week, hand back the cached URL instead of re-billing.
• Handle failed cleanly. Show the human-readable error.message from the response — almost always a content-policy or parameter-shape issue you can fix in the next message.

Frequently asked questions

Is OpenClaw really free?

Yes. OpenClaw is open source under the MIT license. The only things you pay for are the LLM provider you choose (Anthropic, OpenAI, or a local model) and any external APIs your Skills call — like Unifically.

Can I run OpenClaw without OpenAI or Anthropic?

Yes. OpenClaw is provider-agnostic. Many users run it on local Ollama models or through OpenAI-compatible gateways. You can swap providers any time without losing memory or Skills.

How much does Veo 3.1 cost through Unifically?

Veo 3.1 starts at $0.075 per video for Lite Relaxed, $0.30 for Fast, and $0.60 for Quality on Unifically. Live pricing for every model is on the pricing page and on each model page.

Does OpenClaw send my prompts to a server we control?

No. OpenClaw runs on your hardware. The only outbound calls are the ones you configure — your LLM provider, your messaging channels, and any APIs your Skills hit (like Unifically). Your context, memory, and Skill code never leave your machine.

Is Unifically affiliated with OpenClaw?

No. OpenClaw is an independent open-source project by Peter Steinberger and its contributors. We are not affiliated. We just believe Unifically is the cleanest way to give an OpenClaw assistant the ability to generate video, images, music, and voice on demand.

Ship it

You are three steps away from an agent that can render a Veo clip from a Telegram message:

1. Install OpenClaw — one command, a few minutes.
2. Grab a Unifically API key — pay-per-generation, no subscription.
3. Pick your favorite path: ask OpenClaw to build the Skill (Step 4), paste the drop-in SKILL.md (Step 5), or use the TypeScript code (Step 6).

Then go enjoy yelling "render me a cinematic of my dog as an astronaut" into your phone and getting a real MP4 back ten seconds later.

Related reading

• OpenClaw overview on Unifically
• All 80+ models on Unifically
• Veo 3.1 deep dive and Suno deep dive
• Veo 3.1 vs SeeDance 2.0 comparison
• OpenClaw official site and docs.openclaw.ai
• openclaw/openclaw on GitHub