Give Claude or Cursor File Conversion With a Free MCP Server

Large language models are good at talking about files and bad at actually opening them. You can paste a path into Claude or Cursor and ask it to turn a HEIC photo into a JPG, merge three PDFs, or transcribe a voice memo, and the model will either invent a command or tell you to install a toolbox of local binaries. If you already live in an MCP-compatible editor, there is a simpler option: point the client at a remote file-conversion server and let the model call real tools.

CleverUtils exposes a free MCP server at https://cleverutils.com/mcp. There is no API key and no signup. This article walks through what the server offers, how to hook it into Cursor or Claude Desktop, how to test it with curl, and where the limits are. The same engine also has a REST API if you would rather call it from a script or from CI.

What you get

The server speaks JSON-RPC 2.0 over Streamable HTTP. You POST requests to https://cleverutils.com/mcp. There is no session state and no authentication. Rate limits are per IP, the same model as the REST API: 1000 calls per day, 150 per hour, and a one-second gap between calls. Heavy AI tools sit on a tighter cap of 50 per day. Each file can be up to 200 MB, with a smaller ceiling on some AI jobs. Output download links expire after two hours.

Inputs accept either an HTTPS URL (the server fetches the file itself, behind SSRF protections) or a base64-encoded file. Results come back as MCP resource_link blocks that point at a temporary download URL.

Fifteen tools are available today:

• convert_file: universal converter (200+ format pairs). Params include file, to_format, plus optional img_quality and img_resize_w / img_resize_h.
• upscale_image: Real-ESRGAN upscale at 2x, 3x or 4x (file, scale, model).
• remove_background: subject cut-out to a transparent PNG.
• colorize_photo, restore_old_photo, enhance_photo: photo repair tools.
• vocal_remover: separate vocals from a track (Demucs).
• speech_to_text: Whisper transcription to text, SRT or VTT (file, format, language).
• noise_reduction: audio cleanup (DeepFilterNet3).
• resize_image and compress_image.
• compress_pdf and merge_pdfs (the merge tool takes 2-20 files).
• get_job_status and list_supported_formats (the list call does not count against quota).

The MCP documentation is the source of truth if a parameter name changes.

Hook it up in Cursor

Current Cursor builds can talk to a remote Streamable HTTP server directly. In MCP settings, add:

{
  "mcpServers": {
    "cleverutils": {
      "url": "https://cleverutils.com/mcp"
    }
  }
}

If your build does not yet accept the url shape, use the mcp-remote proxy shown in the Claude Desktop section below. After a reload, the tools should appear in the tool picker.

Hook it up in Claude Desktop

Claude Desktop still launches MCP servers as local processes, so a remote HTTP endpoint needs a small stdio-to-HTTP bridge. The usual one is the official mcp-remote package, run through npx (Node.js has to be installed):

{
  "mcpServers": {
    "cleverutils": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://cleverutils.com/mcp"]
    }
  }
}

On macOS the file is ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows it is %APPDATA%\Claude\claude_desktop_config.json. Restart Claude Desktop after you save it. Cline, Continue and Zed follow the same pattern: use the native url shape where the client supports it, otherwise the npx proxy.

Try it without an editor

You can confirm the server is up from a terminal before you touch any client config.

Initialize:

curl -X POST https://cleverutils.com/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": {"name": "curl", "version": "1.0"}
    }
  }'

List tools:

curl -X POST https://cleverutils.com/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

Call a tool (the file must be a real, publicly reachable HTTPS URL):

curl -X POST https://cleverutils.com/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "convert_file",
      "arguments": {
        "file": "https://example.com/photo.heic",
        "to_format": "jpg"
      }
    }
  }'

Always start with tools/list if you are writing a client. The catalog and schemas can grow, and that call is free against the daily quota.

Prompts that actually work

Once the server is connected, ask for a concrete file and a concrete output:

• "Convert https://example.com/photo.heic to JPG."
• "Upscale this image 4x: https://example.com/icon.png"
• "Remove the background from https://example.com/portrait.jpg and give me the transparent PNG."
• "Transcribe this podcast as SRT subtitles in English: https://example.com/episode.mp3"
• "Merge these three PDFs into one: https://example.com/a.pdf, https://example.com/b.pdf, https://example.com/c.pdf"

Vague prompts ("clean up my documents") give the model too much room to pick the wrong tool. Named formats and URLs work better.

Safety and when not to use it

Because the server is public and unauthenticated, treat it like any other remote converter. The fetch path blocks private IP ranges, link-local addresses, cloud metadata endpoints and file:// URLs, and it pins DNS to limit rebinding. That protects the host. It does not make a confidential document public-safe. If a file should not leave your machine, convert it locally.

Download results promptly. Links are dropped after two hours, and there is no later recovery. For current numbers and response headers, see the rate limit documentation.

If you are building a batch job, a GitHub Action or a backend service, the REST API is the better fit: POST /api/v1/convert for a single file, POST /api/v1/batch for up to 20, then GET /api/v1/jobs/{job_id}/output to download. MCP is for the chat and editor loop, where you want the model to pick a tool and return a file.