Low-Res Images, High-Res Problems
You’re reviewing a pull request and notice the product images are 300x300. The design spec says 1200x1200. The originals are gone — the supplier sent what they sent, and nobody kept higher-resolution versions.
You could download the images, run them through a Python upscaling script, install the dependencies, wait for the model to process, and re-upload. Or you could ask your AI assistant to do it in one sentence.
MCP makes this possible. The Model Context Protocol lets AI assistants like Claude Desktop and Cursor call external APIs as tools. Connect the Image Transformation API as an MCP server, and your assistant can upscale, resize, crop, and convert images directly from a conversation. Describe what you need, it calls the API, you get the result.
No scripts. No dependencies. No context switching.
What MCP Is
Model Context Protocol is an open standard that gives AI assistants the ability to discover and call external services. Think of it as a plugin system — you register a tool, and the assistant uses it when your request matches.
When you connect the Image Transformation API as an MCP server, your assistant gains a full suite of image operations: upscaling low-resolution images at 2x, 3x, or 4x, resizing to exact dimensions, cropping, and converting between formats. All from a single MCP server.
The upscaling capability is not interpolation. The API uses an AI super-resolution model that generates actual detail — texture, edges, fine patterns — that didn’t exist in the original pixels. A blurry 500x500 image at 4x becomes a sharp 2000x2000 image with real visual information.
Setting Up in Claude Code
Claude Code supports MCP servers natively. Add the Iteration Layer server with a single command:
claude mcp add iterationlayer --transport streamablehttp https://api.iterationlayer.com/mcpThe first time you use an Iteration Layer tool, a browser window opens for OAuth authentication. Log in, authorize access, and you’re connected. No API keys to manage.
To verify the server is available, start a conversation and ask Claude Code what MCP tools it has access to. You should see transform_image listed among the available tools.
Setting Up in Cursor
Add to your .cursor/mcp.json:
{
"mcpServers": {
"iterationlayer": {
"type": "streamablehttp",
"url": "https://api.iterationlayer.com/mcp"
}
}
}Save and restart. The Image Transformation tool is now available in your Cursor AI conversations. Authentication works the same way — OAuth in the browser on first use.
Using It Conversationally
Upload an image and describe what you need:
“Upscale this product image to 4x resolution.”
The assistant calls the Image Transformation API with an upscale operation at factor 4, and returns the upscaled image. A 500x500 input becomes 2000x2000 with generated detail — not blurred pixels.
“This logo is too small for the print layout. Upscale it to 2x.”
The assistant uses a 2x factor, doubling the resolution while preserving the logo’s sharpness.
“Upscale this photo to 3x for the hero banner.”
Three times the resolution. The model generates texture and edge detail that makes the image hold up at the larger size.
More MCP Conversations
The conversational pattern scales beyond single-image requests. Here are a few more interactions that show what’s possible.
Comparing factors side by side:
“Upscale this photo at 2x and 4x so I can compare the results.”
The assistant makes two separate API calls — one with factor 2, one with factor 4 — and returns both images. You compare them in the conversation and pick the one that balances file size and quality for your use case.
Upscaling a batch of icons:
“I have these five SVG-exported PNGs at 64x64. Upscale each one to 4x for the app store assets.”
The assistant processes each image individually through the API. Five calls, five results, all in one conversation thread. No script, no loop, no dependencies to install.
Chaining multiple operations:
Because the Image Transformation MCP server handles upscaling, resizing, cropping, and format conversion in a single server, you can chain operations naturally:
“Upscale this image to 3x, then convert it to WebP and resize it to exactly 1200x800.”
The assistant chains the operations through the Image Transformation API — upscale, format conversion, and resize — all in one conversation.
“This supplier photo is 400x300. Upscale it to 4x, then crop it to a square and compress it under 200KB.”
The assistant runs the upscale (producing a 1600x1200 image), then chains a crop and a target-size compression. What would normally be three scripts or a multi-step CLI pipeline becomes one sentence.
When to Upscale
Legacy images. Old product catalogs, archived marketing materials, images from systems that stored thumbnails as the “original.” The high-res version doesn’t exist. AI upscaling is the only way to recover usable resolution.
Supplier-provided images. E-commerce teams deal with this constantly. Suppliers send images at whatever resolution they have — often 300x300 or 400x400. Marketplaces require 1000x1000 minimum. Traditional upscaling produces blurry results. AI upscaling generates the detail needed to meet the spec.
Print preparation. An image looks fine on screen at 72 DPI but falls apart at 300 DPI for print. Upscaling 2x or 4x gives you enough resolution for print-quality output without visible artifacts.
User uploads. Users upload whatever they have — phone screenshots, cropped thumbnails, profile pictures from 2015. If your application needs a larger version, AI upscaling is better than showing a blurry stretched image.
Choosing a Factor
The API supports three upscaling factors. Each one multiplies both dimensions:
- 2x — a 500x500 image becomes 1000x1000 (4x the pixels). Good for images that are close to the target resolution but need a bump.
- 3x — a 500x500 image becomes 1500x1500 (9x the pixels). A solid middle ground for most use cases.
- 4x — a 500x500 image becomes 2000x2000 (16x the pixels). Maximum enhancement. Best for images that are significantly below the target resolution.
Higher factors mean more generated detail. The model is filling in information that wasn’t in the original, so there’s a practical limit — upscaling a 50x50 icon to 4x won’t produce a photo-realistic 200x200 image. For best results, start with the smallest factor that gets you to the resolution you need.
What Happens Under the Hood
When the assistant calls the API, it sends a POST request to https://api.iterationlayer.com/image-transformation/v1/transform with your image and the desired operations. The request body specifies the file and a list of operations — for example, { "file": {"type": "url", "name": "image.jpg", "url": "..."}, "operations": [{"type": "upscale", "factor": 4}] }. The AI model processes the image, generating new pixels based on patterns it learned from millions of high-resolution images.
You can chain multiple operations in a single request — upscale, then resize, then convert to WebP — and the API processes them in sequence. This is what makes the single MCP server so versatile: one connection gives you the full image transformation pipeline.
Quality Expectations
AI upscaling is not magic, and setting expectations correctly matters. The model works best on photographs and natural images — textures, skin, hair, fabric, foliage. These have predictable patterns the model has learned to extend.
It works well on product photography. Supplier images that arrive at 400x400 upscale to 1600x1600 with believable detail. Edges stay sharp, product surfaces gain texture, and the result passes visual inspection at marketplace-required dimensions.
It works less well on text and sharp geometric shapes. A screenshot with small text at 300x200 upscaled to 4x will have smoother text, but it won’t match the crispness of a native-resolution render. For images with prominent text, 2x is usually the practical ceiling before artifacts become noticeable.
Icons and logos fall somewhere in between. Simple shapes with flat colors upscale cleanly. Detailed logos with fine lines may gain subtle softness at higher factors. If you need pixel-perfect scaling for vector-origin artwork, re-exporting from the source SVG at the target resolution is always better — but when the source file is gone, 2x upscaling is a reasonable recovery option.
MCP vs Direct API Calls
MCP is built for ad-hoc work. You need one image transformed, right now, without writing code. The assistant handles the API call, the file encoding, the response parsing. You describe, it delivers.
For production pipelines — upscaling product images during catalog import, processing user uploads on the fly, batch-enhancing legacy image libraries — use the API directly. The request body is JSON. Any language that can make an HTTP POST can transform images.
The two approaches fit different moments. Prototype in conversation with MCP, then move the pattern into your codebase when it becomes a recurring workflow.
Common Pitfalls
Upscaling already-compressed JPEGs. Heavy JPEG compression creates visible block artifacts. Upscaling amplifies those artifacts rather than removing them. If the source image is heavily compressed, the upscaled version will look better than bicubic interpolation, but the compression artifacts will still be visible. Start from the highest-quality source you have.
Using 4x when 2x is enough. Higher factors produce larger files and longer processing times. If you need a 1000x1000 image and your source is 600x600, 2x gives you 1200x1200 — more than enough. Save 4x for cases where the source is genuinely small relative to the target.
Expecting upscaling to fix motion blur or focus issues. AI upscaling generates detail from patterns, but it cannot recover information that was never captured. A blurry photo becomes a larger blurry photo. The model may sharpen some edges, but fundamental focus problems remain.
Get Started
Sign up for a free account at iterationlayer.com — no credit card required. Run the claude mcp add command above, authenticate in the browser, and transform your first image from your next Claude Code or Cursor conversation.
The docs cover the full API reference — request format, response format, file size limits, supported operations, and factor options.