Iminify

npx add-mcp 'https://www.iminify.com/mcp'

Iminify runs an MCP server, so an AI agent can compress, convert and resize images and scan pages for you, straight from the chat or the editor you already use. Ask Claude to "make these product photos WebP under 1600 pixels wide" and it calls Iminify, waits for the results and hands you the download links.

The server lives at one address:

https://www.iminify.com/mcp

It speaks MCP over streamable HTTP and signs you in with OAuth, so most apps only need that address. The first time you connect, the app sends you to Iminify to approve it, and from then on it works as you: your images, your plan, your counts.

Connecting an app

You need an account with a verified email address. The free plan works.

Claude

In Claude (the web app or the desktop app), open Settings, then Connectors, and add a custom connector with the address above. Claude opens Iminify in a browser tab; sign in if you aren't already, check what it asks for, and press Approve.

Claude Cowork

Cowork uses the connectors on your Claude account, so once Iminify is connected in Claude, a Cowork task can use it too: switch it on for the task and ask. To let Cowork work through a folder of images on your computer and write the smaller files back, add the Iminify plugin as well.

Claude Code

The quickest way is the Iminify plugin, which adds the server and a skill that optimizes a whole project's images (more about it below). Type these two commands into Claude Code:

/plugin marketplace add mozex/iminify-plugin
/plugin install iminify@iminify

To add only the server, run this in your terminal instead:

claude mcp add --transport http iminify https://www.iminify.com/mcp

Either way, run /mcp inside Claude Code and pick Iminify to sign in.

Cursor

Add the server to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project:

{
  "mcpServers": {
    "iminify": {
      "url": "https://www.iminify.com/mcp"
    }
  }
}

Cursor shows a sign-in button next to the server in its MCP settings.

VS Code

Add it to .vscode/mcp.json in your workspace:

{
  "servers": {
    "iminify": {
      "type": "http",
      "url": "https://www.iminify.com/mcp"
    }
  }
}

ChatGPT

ChatGPT connects to MCP servers as connectors. Custom ones currently sit behind developer mode in its settings; create a connector with the address above and OAuth as the sign-in, and approve it on Iminify when ChatGPT sends you there.

Anything else

Any client that speaks MCP over HTTP can use the same address. If it can't do OAuth, give it an API key instead, sent as a header on every request:

Authorization: Bearer <your-api-key>

In Claude Code that's claude mcp add --transport http iminify https://www.iminify.com/mcp --header "Authorization: Bearer $IMINIFY_API_KEY".

What the agent can do

Tool	What it does
compress_images	Compress, convert or resize up to 20 images in one call, from their addresses, from upload links, or sent inline
create_upload_link	Get a one-time address to send a local file to
get_image	One image's status, sizes, savings and download links
list_images	Your images, newest first, filtered by status, source or scan
create_zip	One download link for several finished images, or all of a scan's
scan_page	Scan a web page for every image it loads and compress them all
get_scan	A scan's progress, its images and what it saved
rename_image	Change the name a result downloads under
share_image	Give a result a public page to send to someone
delete_image	Delete an image and both its files, for good
get_usage	Your plan, its limits and what today has used

The settings are the API's: a level, a format, a width, a height or a scale, and whether to keep the metadata. You rarely need to name them. Say what you want in plain words and the agent picks them.

The Iminify plugin

The Iminify plugin is open source on GitHub, and it works in Claude Code and Claude Cowork. It connects the app to the server and adds one skill, optimize-images, which does the whole job of optimizing a project's images, or any folder of them:

1. It finds the images you name, or every image the project tracks in git, leaving out dependency and build folders.
2. It shows you the list and the settings it will use, and waits for a yes.
3. It uploads each file through an upload link, compresses them on your account and waits for the results.
4. It writes each smaller file over the original. A file Iminify couldn't make smaller stays as it was.

It never overwrites a file git couldn't give back: one with uncommitted changes waits for your say-so. A new format means a new file name, so it converts only when you ask, saves the new file beside the old one and updates the references it finds. Ask in plain words, like "optimize the images in public/images" or "convert the PNGs in resources/img to WebP", or run it as /iminify:optimize-images.

To install it:

• Claude Code: type the two commands under Claude Code above, then run /mcp and sign in to plugin:iminify:iminify.
• Claude Cowork: open Customize, then Plugins, add a marketplace from a repository with https://github.com/mozex/iminify-plugin, and install Iminify. Sign in to it the first time Cowork asks. Then hand Cowork a folder, say "optimize the images in this folder", and it takes it from there.

Every image it compresses counts toward your plan, like any other.

Files on your computer

An agent in the cloud, like Claude on the web, can only work with images that have an address on the internet, or small files it sends inline. An agent that can run commands on your machine, like Claude Code or Cursor, can send local files of any size your plan takes:

1. It calls create_upload_link with the file's name and gets back an address that works once, for 15 minutes.
2. It sends the file there with a PUT, the way this command does:

   curl --fail --upload-file hero.png "<upload_url>"
   

3. It calls compress_images with the upload_id it got in step 1.

A file that is sent but never compressed is deleted about a day after it arrives. Inline files, sent as base64 inside the call, are limited to 4 MB each; anything bigger goes through an upload link.

Results come back as links

The server never puts image bytes in its answers. Every image comes with a download_url for the optimized copy and another for the original, and create_zip gives one for a whole batch. These links work without a key, so the agent can fetch them or simply show them to you, and they stop working after 60 minutes. Ask again for fresh ones.

Work runs in the background, as it does everywhere else. compress_images and scan_page answer straight away with the work queued, and the agent checks back with get_image or get_scan until it's done. Each answer carries a hint when there is something to wait for or to know, like an image Iminify couldn't make any smaller with the settings used.

Limits

The MCP server is one more door onto your account, not a separate one. Every image an agent queues counts against your plan's daily images and compressions a minute, the same counts the website and the API spend, and every call to the server counts as an API request. Limits and quotas explains each one, and the pricing page has the numbers for every plan.

When a limit is reached, or anything else is refused, the tool answers with an error carrying the API's message and code (listed on the errors page), plus retry_after in seconds when waiting will help. A good agent tells you the message rather than retrying in a loop.

Disconnecting an app

Settings > Connected apps lists every app you've approved, with when it last called. Disconnect one there and it stops working straight away; it has to be approved again to come back. An app that goes unused for 30 days has to be connected again anyway.

An app connected with an API key instead is removed by deleting that key in Settings > API Tokens.