⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.0

pixelbin

anandpareek-hub@anandpareek-hub⭐ 16 stars· last commit 6mo ago· 0 open issues

Use when the user wants to generate AI images or videos, transform/edit existing media, build production media pipelines, get CDN URLs for images/videos, do bulk image processing (background removal, watermark removal, upscaling, resizing), generate SEO content for pages, or build landing pages with AI-generated visuals. Powered by PixelBin's 85+ AI APIs and 60+ URL-based transformations.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 16 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

PixelBin Claude Skill

Turn Claude into a full media pipeline for AI image generation, AI video generation, image transformation, background removal, watermark removal, image upscaling, and bulk image processing — backed by a global image CDN and DAM.

Claude skill for AI image generation (nanoBanana / nanoBanana 2 / nanoBanana Pro), AI video generation (Sora 2, Veo 3, Kling 3, Hailuo, Seedance, LTX-2, Wan 2.5), 60+ chainable image transformation operations (resize, crop, WebP/AVIF format conversion, watermark, compress, sharpen, smart-crop), background remover, watermark remover, AI image upscaler, photo restoration, colorization, OCR, image editing, and image-to-video — delivered over a built-in CDN with DAM.

Get API Key Pricing Docs License


🚀 The Wow

"Drop 50 product photos in a Claude conversation. Get back e-commerce-ready images — backgrounds removed, upscaled to 4K, watermarked, resized for Amazon, Shopify, and Instagram — in one prompt."

That's not a roadmap. That's what this skill does, today.


✨ Created with just one prompt

📸 See more → SHOWCASE.md


🆚 How this is different

Most AI-media skills give Claude a single API call. PixelBin gives Claude a production media stack.

Generic AI media skillsPixelBin Claude Skill
One-off API callsFull media pipeline — generate → store → transform → deliver
Image gen, OCR, bg-remove…85+ AI APIs: image gen, video gen, OCR, upscale, bg-remove, watermark remove, restore, colorize, expand, relight, frame-interp, video upscale, video watermark remove, +many more
Stateless, no CDNBuilt-in global CDN — edge cache, HTTP/3, signed URLs, custom domains
Per-call billingURL-param transformations — chain t.resize()~t.toFormat(f:webp)~t.compress() infinitely, free
No bulk pipelinesBuilt for batch — process hundreds in one job, resumable
Just an APIIncludes DAM — folders, tags, search, access controls, bulk ops

📌 Powered by the same media infrastructure trusted by enterprise retail brands in production.


🧰 What's inside

1. 85+ AI APIs for image generation, video generation & editing

AI image generation (nanoBanana, nanoBanana 2, nanoBanana Pro), AI video generation (Sora 2, Veo 3, Kling 3, Hailuo, Seedance, LTX-2, Wan 2.5), background removal, watermark removal, AI image upscaling, video upscaling, OCR, photo restoration, colorization, image expansion (outpainting), AI relighting, object removal, frame interpolation, image captioning, sketch-to-image, image-to-video, AI photo editor, and more. → references/apis.md

2. 60+ image transformation operations — chainable in one URL

Image resize, crop, format conversion (WebP / AVIF / JPEG / PNG), quality / compression, watermark, blur, sharpen, brightness, saturation, rotation, padding, tinting, smart-crop, focal-point cropping, art-style presets, and more — all chainable in a single CDN URL with no extra API call. → references/transformations.md

3. Built-in image & video CDN — global edge delivery

Every uploaded asset gets a cdn.pixelbin.io/v2/... URL with HTTP/3, edge caching, signed URLs, and custom domains — production-grade image CDN and video CDN out of the box. → references/cdn.md

4. DAM (Digital Asset Management) for images & videos

Folders, tags, full-text search, access controls (public-read / private), bulk ops, metadata. Manage thousands of images and videos without spinning up your own storage layer.

5. Bulk image processing & batch pipelines

Concurrency-safe batch runners, resumable jobs, progress checkpointing. Bulk image generation (500+ images while you sleep), bulk image transformation (10,000+ product shots in a script), bulk background removal, bulk watermark removal, bulk image upscaling.


📦 What you can build

Use caseTools usedLive page
🛍️ E-commerce hero shots at scaleimage-gen + bg-remove + upscale + resizeAI Image Generator
🧹 Bulk watermark cleanupwatermark-removerWatermark Remover
🔍 4K upscaling for print/marketingimage-upscaleAI Image Upscaler
✂️ One-click background removalbg-removeRemove Background
🎬 AI video generation (text/image → video)video-gen (Veo 3 / Sora 2 / Kling 3)AI Video Generator
🎨 AI image editing (inpaint, expand, relight)nanoBanana 2 / ProAI Photo Editor
🌈 Old photo restoration & colorizationrestore + colorizePhoto Restoration
📄 Landing-page generation (SEO + images)seo-content + image-gen + build-page—

⚡ Quickstart (3 steps, ~2 minutes)

1. Install

git clone https://github.com/anandpareek-hub/

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/pixelbin/SKILL.md7.9 KBupstream ↗
    ---
    name: pixelbin
    description: Use when the user wants to generate AI images or videos, transform/edit existing media, build production media pipelines, get CDN URLs for images/videos, do bulk image processing (background removal, watermark removal, upscaling, resizing), generate SEO content for pages, or build landing pages with AI-generated visuals. Powered by PixelBin's 85+ AI APIs and 60+ URL-based transformations.
    ---
    
    # PixelBin Claude Skill
    
    Turn Claude into a full media pipeline. Generate, transform, store, and deliver images & videos at scale using PixelBin.
    
    ## When to use
    
    - User wants to generate images (nanoBanana, nanoBanana 2, nanoBanana Pro)
    - User wants to generate videos (Sora 2, Veo 3, Kling 3, Hailuo, Seedance, LTX-2, Wan)
    - User wants to remove backgrounds, watermarks, or upscale images/videos in bulk
    - User wants permanent CDN URLs for media
    - User wants to build URL-based image transformations (resize, crop, format, quality, etc.)
    - User wants to generate SEO content (titles, meta, FAQ schema, briefs)
    - User wants to build a landing page with AI-generated images stitched together
    - User mentions "PixelBin", "nano banana", "build a media pipeline", "bulk image processing"
    
    ## First-run behaviour (IMPORTANT)
    
    Read [`INTRO.md`](INTRO.md) before responding. INTRO.md is the user-facing voice of this skill — match its tone and follow its "How Claude should respond" section.
    
    **If the user has already stated a clear goal** (e.g. "generate 6 hero images for X", "remove backgrounds from these photos", "build a landing page for Y"):
    1. Confirm `.env` and `node_modules/` are ready (see Setup check below) — auto-fix silently if you can.
    2. **Confirm model + key options in ONE friendly line** (don't make them write JSON — give a default they can accept with "go"):
       - **Image gen:** _"Quick pick: **nano banana 2** (default, balanced) or **nano banana Pro** (premium quality, slower)? Aspect: 1:1 / 16:9 / 9:16 / 4:5 (default 1:1). Resolution: 1K / 2K / 4K (default 2K). Or just say 'defaults' and I'll use nano banana 2 · 1:1 · 2K."_
       - **Video gen:** _"Quick pick: **Veo 3 Fast** (default, balanced cost), **Veo 3** (premium), **Sora 2** (with audio), **Kling 3** (cinematic), or **Hailuo 2.3** (1080p)? Duration: 4 / 6 / 8s (default 6). Aspect: 16:9 / 9:16 / 1:1 (default 16:9)."_
       - **Resize/format:** safe to default silently → `t.resize(...)~t.toFormat(f:webp)~t.compress()`.
       - If the user already specified everything in their prompt, skip the picker and just run.
    3. Run the right scripts under the hood and hand back CDN URLs.
    
    **If the user is just exploring** ("hi", "what can you do?", "help"):
    1. Greet them and present the **broad buckets** from INTRO.md (image gen, image edit, transformation, AI cleanup, video, bulk, SEO, landing pages).
    2. Show **one concrete example prompt + a sample CDN URL** from INTRO.md so it feels real and easy.
    3. Invite them to just say what they want in plain English. No CLI talk.
    
    **Default to chat-first.** Don't expose CLI flags, JOBS arrays, model names, or transform syntax unless the user asks "how does this work?". Run scripts silently; report results visually.
    
    ## Handling images the user provides (CRITICAL)
    
    When the user references an image, **you must obtain it yourself** — never ask them to "give me a file path" or "save it to Downloads". The image is already accessible to you in one of these forms:
    
    | What the user did | What you do |
    | --- | --- |
    | **Pasted an image inline in the chat** | The image is in your conversation context. Use the `Write` tool to save the bytes to `./scripts/_inputs/<slug>.<ext>`, then upload it via `pixelbin.assets.fileUpload({ file: fs.createReadStream(...) })` to get a permanent CDN URL. Pass that URL into `images: [...]` for the prediction. |
    | **Gave you a public URL** (e.g. `https://example.com/photo.jpg`, a CDN URL, a Slack/Drive public link) | Two options:<br>• **Quick path** — pass the URL straight into `images: [url]` of `pixelbin.predictions.createAndWait` (most models accept a URL). No upload needed.<br>• **Permanent path** — call `pixelbin.assets.urlUpload({ url, path: '<folder>', name: '<slug>', access: 'public-read' })` to store it in PixelBin DAM, then use the resulting CDN URL. |
    | **Gave a local path** (`~/Downloads/photo.jpg`, `./photo.jpg`) | Use `pixelbin.assets.fileUpload({ file: fs.createReadStream(absPath), ... })`. |
    | **Mentioned an image but didn't attach or link it** | _Now_ ask — but politely: _"Drop the image into the chat or paste a URL — I'll handle the rest."_ |
    
    **Never** say "the inline image isn't saved on disk, please paste the path" — that's a user-experience failure. Saving inline image bytes to disk is your job, not theirs.
    
    ## Cost-aware path selection (CRITICAL)
    
    **Before reaching for a generation model, decide whether the task needs generation at all.** Generation models are the most expensive op in the stack. For most product / e-commerce / variant tasks, you can do the same job with a cheap prediction + free URL transforms.
    
    ### Decision tree
    
    | User intent | Cheap path (use this) | Expensive path (avoid unless asked) |
    | --- | --- | --- |
    | **"Same product, white bg, marketplace-ready"** (Amazon, Shopify, Flipkart, etc.) | 1. `erase_bg` prediction → transparent PNG<br>2. Upload to DAM<br>3. URL transform: `t.extend(...,bc:ffffff)~t.resize(h:H,w:W)~t.toFormat(f:webp)~t.compress()` | nanoBanana regenerate (loses product fidelity, ~10× cost) |
    | **"Resize / reformat / compress / different aspect ratio"** for an existing image | URL transforms only — `t.resize`, `t.toFormat`, `t.compress`, `t.extend` (free, just CDN params) | Regeneration |
    | **"Upscale to 4K"** | `vsr_upscale` prediction (or `t.resize` if source is large enough) | Regeneration at higher res |
    | **"Remove watermark"** | `wm_remove` / `wmrPro_remove` / `wmrMax_remove` prediction | Regeneration |
    | **"Remove background and place on new scene"** | `erase_bg` + composite via `t.merge` / generation only for the new background | Full regeneration of the whole image |
    | **"Generate a NEW scene / NEW product shot / hero image from scratch"** | Generation model (nanoBanana 2 / Pro) — this is the right tool | — |
    | **"Variants of the same hero (color, angle, style change)"** | Image-to-image with `nanoBanana2_generate` + `images:[ref]` (preserves identity) | Text-only regeneration (loses identity) |
    
    ### Cost ranking (rough, lower → cheaper)
    1. **URL transforms** — free, no API call
    2. **Plugin transforms** in URL (when activated) — free per request, included in plan
    3. **Predictions: `erase_bg`, `wm_remove`, `vsr_upscale`** — small per-call credit cost
    4. **Image generation** — `nanoBanana_generate` < `nanoBanana2_generate` < `nanoBananaPro_generate`
    5. **Video generation** — most expensive op; always confirm before spending
    
    ### Worked example — "Amazon + Shopify + Instagram-ready, white bg, 4K, 1:1 + 9:16"
    
    **Wrong** (what NOT to do): regenerate each variant with nanoBanana — 12 outputs × generation cost, plus product hallucination risk.
    
    **Right** (default behavior):
    ```
    For each source image:
      1. urlUpload(source)                                        → CDN URL
      2. predictions.createAndWait({ name: 'erase_bg', input: { image: cdnUrl } })  → transparent PNG
      3. urlUpload(eraseBgOutput)                                 → CDN URL of transparent product
      4. Build transform URLs (no API call):
         • Amazon 1:1   t.extend(t:200,r:200,b:200,l:200,bc:ffffff)~t.resize(h:2048,w:2048)~t.toFormat(f:jpeg)~t.compress()
         • Shopify 1:1  t.extend(t:150,r:150,b:150,l:150,bc:ffffff)~t.resize(h:2048,w:2048)~t.toFormat(f:webp)~t.compress()
         • Instagram 9:16  t.extend(t:600,r:200,b:600,l:200,bc:ffffff)~t.resize(h:1920,w:1080)~t.toFormat(f:webp)~t.compress()
    ```
    
    This costs **~1 prediction per source image**, vs **3 generations per source**. Same visual result, fraction of the credits, zero product drift.
    
    ### When in doubt — ask the user
    If a task is borderline (e.g. "make 
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/anandpareek-hub-pixelbin-claude-skill-skills-pixelbin.md

// REPO STATS

16 stars
0 open issues
Last commit: 6mo ago