DEV Community: TheGlitch

Image Processing in Your AI Workflow: TheGlitch MCP Integration

TheGlitch — Thu, 05 Mar 2026 20:16:59 +0000

If you've been following MCP (Model Context Protocol) adoption over the past few months, you've probably noticed a pattern: the most useful MCP servers are the ones that replace something you were already doing manually.

TheGlitch just became one of those.

Quick Background

TheGlitch is a stateless image processing API — REST endpoints for resize, format conversion, effects, AI background removal, optimization, and social media presets. Nothing stored, everything processed in memory and returned as binary.

It's been on RapidAPI since February. What's new is that it's now available as an MCP server, which means you can call it from Claude Desktop, Claude Code, Cursor, VS Code, or any MCP-compatible client using natural language.

Setup (90 Seconds)

1. Get a RapidAPI key

Free plan: 500 requests/month, no credit card.
→ rapidapi.com/theglitchapp/api/theglitch-image-processing

2. Add MCP config

{
  "mcpServers": {
    "TheGlitch Image Processing": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.rapidapi.com",
        "--header",
        "x-api-host: theglitch-image-processing.p.rapidapi.com",
        "--header",
        "x-api-key: YOUR_RAPIDAPI_KEY"
      ]
    }
  }
}

Config file location by client:

Client	File
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`
Claude Code	`.mcp.json` (project root)
Cursor	`.cursor/mcp.json`
VS Code	`.vscode/mcp.json`

Node.js required (for npx). No manual package installs — npx fetches mcp-remote automatically on first run.

3. Restart your AI client

That's it.

What's Exposed

Seven endpoints map directly to MCP tools:

Tool	What It Does
`process`	Full pipeline: resize + effects + format conversion in one call
`resize`	Resize to width, height, or both with a resize mode
`convert`	Convert between JPEG, PNG, WebP, GIF, BMP
`effects`	Brightness, contrast, saturation, blur, sharpen, grayscale, sepia, rotate, flip
`remove-bg`	AI background removal
`optimize`	File size reduction with quality control
`preset`	Social media presets (instagram-square, facebook-cover, youtube-thumbnail, etc.)

Prompt Examples

These aren't hypothetical — these are real natural language prompts that map cleanly to API calls:

Resize https://example.com/photo.jpg to 800x600 and convert to WebP

Remove the background from this product image

Apply grayscale and increase contrast by 40 to this image

Convert this image to instagram-square format

Optimize this image for web — target 80% quality

The AI resolves the intent, calls the correct endpoint with the correct parameters, and returns the result.

Practical Workflow Examples

Scenario 1: Documentation screenshots

You have 20 screenshots to prepare for docs. Instead of running them through an external tool:

"Resize all images in /docs/screenshots to 1280px wide and convert to WebP"

The AI iterates, calls the API for each file, handles the responses.

Scenario 2: Product image pipeline

"Take product.png, remove the background, then create three versions: instagram-square, facebook-cover, and a 800x600 web version"

Three sequential MCP calls, one instruction.

Scenario 3: Pre-commit image optimization

"Before I commit, optimize all images in public/assets/ to WebP at 85% quality"

How Authentication Works

MCP calls use the same RapidAPI key as direct REST calls. Same plan, same rate limits, same usage counter. No separate key management.

Under the hood, mcp-remote proxies through mcp.rapidapi.com, which RapidAPI hosts. Your key authenticates both channels — you don't need to set up anything separately.

Available Plans

Plan	Requests/month	Price
BASIC	500	Free
PRO	15,000	$12/mo
ULTRA	75,000	$39/mo
MEGA	300,000	$99/mo

Background removal counts as GPU usage, tracked separately from regular CPU requests.

Full API Reference

Everything is documented at theglitch.app/docs — all parameters, response formats, error codes, and the complete MCP setup guide.

If you're building something with this or have questions about the integration, drop a comment.

I Built a Stateless Image Processing API — Here's How It Works

TheGlitch — Sat, 21 Feb 2026 21:41:15 +0000

Every web project eventually runs into the same problem: you need to resize an image, convert a format, maybe add some effects, or strip a background. You can set up ImageMagick, wrestle with Sharp, or build custom pipelines — or you can make one HTTP call.

That's why I built TheGlitch — a stateless image processing API that handles everything in a single request.

The Problem

Image processing infrastructure is surprisingly complex:

Installing native dependencies on different OS targets
Managing temporary files and disk cleanup
Handling format quirks (AVIF support, GIF animation, color profiles)
GPU acceleration for AI operations like background removal
Scaling under load without leaking memory

I wanted an API where you send an image in and get a processed image out. Nothing stored, nothing cached on disk, no state between requests.

How It Works

TheGlitch processes images entirely in memory. The pipeline looks like this:

Input (URL/base64/binary/form) 
  → Decode & Validate 
  → Resize & Crop 
  → Apply Effects 
  → Format Convert 
  → Return Binary

A single GET request can do everything:

curl "https://theglitch.p.rapidapi.com/api/v1/process?\
url=https://picsum.photos/1000&\
width=800&\
format=webp&\
brightness=10&\
contrast=15&\
sharpen=20" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "X-RapidAPI-Host: theglitch.p.rapidapi.com" \
  -o result.webp

Features

Resize & Crop — Four modes: fit (preserve aspect ratio), fill (crop to exact size), pad (add borders), stretch. Resolutions up to 8000x8000px.

Format Conversion — Input/output: JPEG, PNG, WebP, GIF, BMP, TIFF. Quality control per format.

7 Visual Effects — Brightness, contrast, saturation, blur, sharpen, grayscale, sepia. All combinable in one request.

AI Background Removal — GPU-powered, takes about 3 seconds per image. Returns transparent PNG.

14 Social Media Presets — Instagram square, Facebook cover, YouTube thumbnail, LinkedIn banner, and more. One parameter instead of remembering dimensions.

Code Examples

JavaScript:

const response = await fetch(
  'https://theglitch.p.rapidapi.com/api/v1/process?url=IMAGE_URL&width=800&format=webp',
  { headers: { 'X-RapidAPI-Key': 'YOUR_KEY', 'X-RapidAPI-Host': 'theglitch.p.rapidapi.com' } }
);
const blob = await response.blob();

Python:

import requests

response = requests.get(
    'https://theglitch.p.rapidapi.com/api/v1/process',
    params={'url': 'IMAGE_URL', 'width': 800, 'format': 'webp'},
    headers={'X-RapidAPI-Key': 'YOUR_KEY', 'X-RapidAPI-Host': 'theglitch.p.rapidapi.com'}
)

with open('result.webp', 'wb') as f:
    f.write(response.content)

Why Stateless?

Every image is processed in memory and discarded after the response is sent. This means:

GDPR compliant by design — no user data stored, ever
No disk I/O bottleneck — everything happens in RAM
Predictable scaling — each request is independent
No cleanup jobs — nothing to garbage collect

Architecture Decisions

A few things I learned while building this:

SkiaSharp over ImageMagick — Native performance, cross-platform, no external dependencies. The tradeoff is less format support (no real AVIF encoding yet), but WebP covers most use cases.
Replicate for GPU ops — Instead of running my own GPU server, I proxy AI operations through Replicate. Background removal costs about $0.0014 per image with BiRefNet. Cold starts are free for public models.
Separate CPU and GPU rate limits — CPU operations (resize, effects, format) are cheap. GPU operations (background removal) are expensive. Different limits per plan make pricing fair.
Single VPS deployment — Docker Compose with Caddy as reverse proxy, Cloudflare in front for CDN/DDoS/SSL. Total infrastructure cost: under $6/month.

API Endpoints

Endpoint	What it does
`/api/v1/process`	Full pipeline — resize + effects + format
`/api/v1/resize`	Resize only
`/api/v1/convert`	Format conversion
`/api/v1/effects`	Visual effects
`/api/v1/remove-bg`	AI background removal (GPU)
`/api/v1/optimize`	Auto-optimize for web (WebP)
`/api/v1/preset/{name}`	Social media presets

Try It

The API is live with a free tier (500 requests/month). Check out the before/after examples on the website, or try it directly through RapidAPI:

Website with live examples: theglitch.app
API on RapidAPI: TheGlitch Image Processing

I'd love to hear what features you'd find useful. Background removal was the most requested during beta — what would you want next?