What makes flickies notable?

1.1K downloads. Trust evidence available

How should flickies be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

flickies

Self-hosted video REST + MCP API. POST JSON, get a video back. Lipsync (LatentSync 1.5 + Wav2Lip/Wav2Lip-GAN) at /v1/video/lipsync, GFPGAN face restore at /v1/video/restore, pure-ffmpeg ops (trim, concat, transcode incl. gif + fps + codec, scale, mux_audio, extract_audio, thumbnail_grid) under /v1/video/*, and ffprobe metadata at /v1/video/info. file_path (staged) xor file_url in; output_path xor output_url out. Fire-and-forget async jobs (async_job=true → 202 → poll /v1/jobs/{id}) with HMAC-signed webhooks. 11 MCP tools at /v1/mcp. Bearer-token auth. CPU + CUDA images. Use when the user wants to lipsync a face to audio, restore faces in footage, trim/concat/transcode/scale/mux/extract/thumbnail video, probe a video's metadata, or drive any of that from an LLM over MCP.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.1k

Updated

Oct 11, 2026

Version

0.3.17

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.1K downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 1.1K downloadsadoption · observed Oct 11, 2026
Latest release: 0.3.17release · observed Oct 10, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:flickies

Install using `clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:flickies` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/psyb0t/flickies before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-flickies/snapshot"

Documentation

CLAWHUB

147,356 characters of source documentation, loaded on request.

Extracted files

4 files captured from the source.

SKILL.md

---
name: flickies
description: Self-hosted video REST + MCP API. POST JSON, get a video back. Lipsync (LatentSync 1.5 + Wav2Lip/Wav2Lip-GAN) at /v1/video/lipsync, GFPGAN face restore at /v1/video/restore, pure-ffmpeg ops (trim, concat, transcode incl. gif + fps + codec, scale, mux_audio, extract_audio, thumbnail_grid) under /v1/video/*, and ffprobe metadata at /v1/video/info. file_path (staged) xor file_url in; output_path xor output_url out. Fire-and-forget async jobs (async_job=true → 202 → poll /v1/jobs/{id}) with HMAC-signed webhooks. 11 MCP tools at /v1/mcp. Bearer-token auth. CPU + CUDA images. Use when the user wants to lipsync a face to audio, restore faces in footage, trim/concat/transcode/scale/mux/extract/thumbnail video, probe a video's metadata, or drive any of that from an LLM over MCP.
homepage: https://github.com/psyb0t/docker-flickies
user-invocable: true
permissions:
  - network: outbound HTTP to the configured FLICKIES_URL, plus server-side fetch of file_url, delivery to output_url, and HMAC-signed webhook callbacks
  - shell: the documented examples invoke local curl / docker
  - filesystem: manages server-side staged files (upload, fetch, remove) and engine lifecycle (load, evict) on the configured instance
metadata:
  { "openclaw": { "emoji": "🎬", "primaryEnv": "FLICKIES_URL", "requires": { "bins": ["docker", "curl"] } } }
---

# flickies

Self-hosted video toolkit — lipsync, face restore, and ffmpeg ops in one container. POST a JSON body, get a video back. Every video endpoint takes the same input/output contract; drive it from curl, the generated Go/Python clients, or point a function-calling LLM at the MCP endpoint.

Lipsync (`POST /v1/video/lipsync`): drive a face video/image from an audio track. Engines: `latentsync-1.5` (ByteDance, Apache-2.0, commercial-safe default, CUDA-only) and `wav2lip` / `wav2lip-gan` (Rudrabha, fast/low-VRAM, LRS2 non-commercial — refused unless `FLICKIES_ENABLE_NONCOMMERCIAL=1` is set in the **server** env). `restore_face=true` chains GFPGAN over the result.

Face restore (`POST /v1/video/restore`): GFPGAN v1.4 (`gfpgan`, Apache-2.0) — clean up a Wav2Lip mouth crop or old footage, standalone.

ffmpeg ops (pure CPU, no engine): `POST /v1/video/trim`, `/concat`, `/transcode` (mp4/webm/mov/mkv + gif + fps + codec change), `/scale`, `/mux_audio`, `/extract_audio`, `/thumbnail_grid`. Metadata: `POST /v1/video/info` (ffprobe).

Extras: async jobs (`async_job=true` → 202 + `job_id` → poll `GET /v1/jobs/{job_id}`), HMAC-signed webhooks on async completion, server-side file staging, engine load/evict control, an MCP endpoint at `/v1/mcp` with 11 tools, optional bearer-token auth.

For installation, configuration, and container setup, see [references/setup.md](references/setup.md).

## Security & safety

- **Auth is off by default** — `FLICKIES_AUTH_TOKEN` is unset out of the box, so the whole API is open to anyone who can reach the port. Set it for any deployment beyond localhost, pass `Authorization

_meta.json

{
  "ownerId": "kn79dhvmpjng4rp2jjk8k0v5xx80ccbk",
  "slug": "flickies",
  "version": "0.3.17",
  "publishedAt": 1791644871846
}

references/setup.md

# flickies setup

## Requirements

- Docker
- Optional: NVIDIA GPU + NVIDIA Container Toolkit for the CUDA image (required for `latentsync-1.5` and `gfpgan`; Wav2Lip runs on CPU too, slowly)
- A bind-mounted `/data` volume for model weights + staged files (weights live in the standard HuggingFace cache layout and are reusable across containers)
- Tested GPU ceiling: **RTX 3060 12 GB** — fits LatentSync 1.5 (~8 GB) with headroom; the Wav2Lip + GFPGAN chain peaks at ~5 GB. One engine resident at a time.

## Quick Install

### CPU

Runs every ffmpeg op (trim / concat / transcode incl. gif / scale / mux / extract / thumbnail-grid / info) plus Wav2Lip-CPU (~44s for a 3s clip — fine for short clips, and only when the non-commercial gate is set). GFPGAN and LatentSync 1.5 are CUDA-only — the CPU image refuses to load them.

```bash
docker run -d --name flickies \
  -v $HOME/flickies-data:/data \
  -p 8000:8000 \
  psyb0t/flickies:latest
```

### CUDA

Runs every engine at usable speed (LatentSync 1.5, Wav2Lip / Wav2Lip-GAN, GFPGAN) plus all ffmpeg ops. Requires the NVIDIA Container Toolkit on the host.

```bash
docker run -d --name flickies \
  --gpus all \
  -v $HOME/flickies-data:/data \
  -p 8000:8000 \
  psyb0t/flickies:latest-cuda
```

Both images `EXPOSE 8000` and bind `0.0.0.0:8000` inside the container (the entrypoint forces `FLICKIES_HOST=0.0.0.0`). Control network exposure at `docker run` time with `-p` (see [Ports](#ports)).

**Verify:** `curl http://localhost:8000/healthz` returns `{"status": "ok"}` once boot is done. `curl http://localhost:8000/v1/health | jq` gives the richer discovery payload (device, ffmpeg version, available/enabled/loaded engines, non-commercial flag).

### Enable the non-commercial engines (Wav2Lip)

Wav2Lip / Wav2Lip-GAN are trained on LRS2 (non-commercial). The server refuses to load them unless `FLICKIES_ENABLE_NONCOMMERCIAL=1` is set. LatentSync 1.5 (Apache-2.0) is the commercial-safe default and needs no gate.

```bash
docker run -d --name flickies \
  --gpus all \
  -e FLICKIES_ENABLE_NONCOMMERCIAL=1 \
  -v $HOME/flickies-data:/data \
  -p 8000:8000 \
  psyb0t/flickies:latest-cuda
```

## Model Weights

Weights live in the standard HuggingFace cache layout under `/data/hf/hub/models--<org>--<name>/…` (content-addressed blobs + snapshot symlinks), reusable by any HF-aware tool sharing the bind mount.

| engine | HF repo | license | gate |
|---|---|---|---|
| `latentsync-1.5` | `ByteDance/LatentSync-1.5` | Apache-2.0 | none (CUDA-only) |
| `wav2lip` / `wav2lip-gan` | `Nekochu/Wav2Lip` | LRS2 non-commercial | `FLICKIES_ENABLE_NONCOMMERCIAL=1` |
| `gfpgan` | `leonelhs/gfpgan` | Apache-2.0 | none (CUDA-only) |
| S3FD detector | `ByteDance/LatentSync-1.5` (bundled) | — | — |

**Lazy by default** — each engine fetches its repo on first request. To pull at boot before the server accepts requests, set `FLICKIES_ENABLED_ENGINES=wav2lip,gfpgan` (prefetch just those) or `FLICKIES_PREFETCH_ALL=1` (prefetch all; CUDA engines

skill-card.md

## Description:

Helps agents use a self-hosted video API to lip-sync footage, restore faces, edit and transcode media, and inspect video metadata through REST or MCP.

This skill is ready for commercial/non-commercial use.

## Publisher:

[psyb0t](https://clawhub.ai/user/psyb0t)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and media creators use this skill to direct a self-hosted video service to lip-sync faces, restore footage, perform common editing operations, and retrieve metadata or processed files.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: Default container setup may expose an unauthenticated video-processing API to the network.

Mitigation: Run on a trusted host, bind the published port to loopback, set FLICKIES_AUTH_TOKEN, and do not expose the API directly to untrusted networks.

Risk: Uploads, remote media inputs, output destinations, and webhook URLs can share media or results beyond the local host.

Mitigation: Use only approved local media and explicitly authorized URLs for remote inputs, outputs, and callbacks.

Risk: Unpinned container images can change between deployments.

Mitigation: Pin Docker images to a version or digest when possible.

## Reference(s):

- [flickies setup guide](references/setup.md)
- [ClawHub skill listing](https://clawhub.ai/psyb0t/skills/flickies)
- [flickies project homepage](https://github.com/psyb0t/docker-flickies)

## Skill Output:

**Output Type(s):** [Guidance, Shell commands, Configuration instructions, API calls]

**Output Format:** [Markdown with JSON and shell examples]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [May guide retrieval of processed video, audio, thumbnails, and metadata from the configured service.]

## Skill Version(s):

0.3.17 (source: ClawHub release metadata)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 2d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.