DEV Community: DishIs Technologies

Automating Workflows with Image Hosting API and MCP Servers

Dishant Singh — Sun, 14 Sep 2025 08:03:08 +0000

Developers can supercharge their applications by integrating Dishis Technologies' Image Hosting API not only into their websites but also into automation workflows and MCP (Model Context Protocol) servers.

Why Use Automations?

Automations reduce repetitive manual work by allowing your app or system to:

Upload product images automatically.
Generate thumbnails on-the-fly.
Handle bulk image processing in background tasks.
Provide image URLs to other services (chatbots, design tools, dashboards).

With our Image Hosting API, you get no bandwidth limits, 35 MB per image support, and flat request-based billing.

Using the API in Automations

Example: Node.js Script for Automated Uploads

import fetch from "node-fetch";

const API_URL = "https://prod.api.market/store/dishis-tech/image/upload";
const API_KEY = process.env.DISHIS_API_KEY; // Store in env for security

async function uploadImage(base64Image) {
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": API_KEY,
    },
    body: JSON.stringify({
      image: base64Image,
    }),
  });

  const data = await response.json();
  console.log("Image uploaded:", data);
  return data;
}

// Example usage
uploadImage("<BASE64_STRING>");

Setting Up for MCP Servers

You can register the Dishis Image Hosting API inside your MCP server configuration for seamless automation.

Example MCP Config

{
  "mcpServers": {
    "dishis_image": {
      "url": "https://prod.api.market/api/mcp/dishis-tech/image",
      "headers": {
        "x-api-market-key": "cm7g...."
      }
    }
  }
}

This allows your MCP-powered agents and tools to call the image hosting API directly.

Example Workflow in MCP

User uploads a design file.
MCP agent triggers the Dishis Image Hosting API.
Response provides permanent URLs + thumbnails.
URLs are stored in your database or sent to downstream apps (CMS, chatbot, ERP).

API Response Example

{
  "data": {
    "id": "Ps9FZHtW",
    "url": "https://i.ibb.co/j9WbvXHw/string.png",
    "display_url": "https://i.ibb.co/CpMm5GW9/string.png",
    "width": 1280,
    "height": 692,
    "size": 96415,
    "image": {
      "filename": "string.png",
      "mime": "image/png",
      "url": "https://i.ibb.co/j9WbvXHw/string.png"
    },
    "thumb": {
      "url": "https://i.ibb.co/Ps9FZHtW/string.png"
    },
    "medium": {
      "url": "https://i.ibb.co/CpMm5GW9/string.png"
    },
    "delete_url": "https://ibb.co/Ps9FZHtW/9205a77cc5c27603389188d7e0e71df3"
  },
  "success": true,
  "status": 200
}

Conclusion

By combining Dishis Technologies' Image Hosting API with MCP servers, you unlock powerful automation capabilities. From bulk e-commerce product uploads to AI workflow integrations, this approach saves time and scales effortlessly.

👉 Start here: Get API Key on RapidAPI

👉 For advanced plans: API Market Store

How to Set Up Our Image Hosting API on Your E-Commerce App or Website

Dishant Singh — Sun, 14 Sep 2025 07:58:50 +0000

When building an e-commerce app or website, managing product images efficiently is crucial. High-resolution photos directly impact user experience and conversion rates. Our Image Hosting API makes it simple to upload, manage, and deliver product images without worrying about bandwidth limits or hidden costs.

In this guide, we’ll walk through how to set up our API in your e-commerce app or site.

Why Use Our Image Hosting API?

Flat pricing – no bandwidth billing, just per-request pricing.
High upload limit – 35 MB per image (5–10x higher than Cloudinary or others).
No auto-delete – your product images stay online.
Flexible uploads – support for binary files, base64, or image URLs.
Free tier available – perfect to test integration before scaling.

👉 Get your API key on RapidAPI: Upload Images Hosting API

For higher usage and bulk plans: Dishis Tech Store

Step 1: Get Your API Key

Sign up on RapidAPI.
Subscribe to a plan that fits your needs.
Copy your API key from the dashboard.

Step 2: Upload an Image

Here’s an example request in JavaScript (fetch):

const url = "https://upload-images-hosting-get-url.p.rapidapi.com/upload";
const data = new FormData();
data.append("image", fileInput.files[0]); // your product image file

fetch(url, {
  method: "POST",
  headers: {
    "X-RapidAPI-Key": "YOUR_API_KEY",
    "X-RapidAPI-Host": "upload-images-hosting-get-url.p.rapidapi.com"
  },
  body: data
})
  .then(response => response.json())
  .then(result => console.log(result))
  .catch(error => console.error(error));

Step 3: Example API Response

The API returns structured JSON with multiple image URLs (viewer, direct link, thumbnail, medium).

{
  "data": {
    "id": "Ps9FZHtW",
    "title": "string",
    "url_viewer": "https://ibb.co/Ps9FZHtW",
    "url": "https://i.ibb.co/j9WbvXHw/string.png",
    "display_url": "https://i.ibb.co/CpMm5GW9/string.png",
    "width": 1280,
    "height": 692,
    "size": 96415,
    "image": {
      "filename": "string.png",
      "url": "https://i.ibb.co/j9WbvXHw/string.png"
    },
    "thumb": {
      "url": "https://i.ibb.co/Ps9FZHtW/string.png"
    },
    "medium": {
      "url": "https://i.ibb.co/CpMm5GW9/string.png"
    },
    "delete_url": "https://ibb.co/Ps9FZHtW/9205a77cc5c27603389188d7e0e71df3"
  },
  "success": true,
  "status": 200
}

Step 4: Integrate Into Your E-Commerce Workflow

Product Upload Flow:
- Let sellers/admins upload product images via your dashboard.
- Call our API to store the images.
- Save the returned url or display_url in your database.
Frontend Display:
- Use the url for product detail pages.
- Use the thumb for category and search result pages.
- Use the medium for cart or recommendation widgets.

Step 5: Manage Storage and Scaling

Use delete_url for removing outdated product images.
Start with Free or Pro plan on RapidAPI, then scale to Mega or Biz plans.
For high-traffic e-commerce sites, check our Bulk plan at Dishis Tech Store.

Conclusion

By integrating our Image Hosting API, your e-commerce app will:

Load product images faster.
Handle high-res photos without hitting limits.
Avoid bandwidth overage charges.

This means better SEO, improved user experience, and higher conversion rates.

👉 Try it today: Upload Images Hosting API

🚀 A Simple, Affordable Image Hosting API (35MB per Image, No Bandwidth Limits)

Dishant Singh — Sun, 14 Sep 2025 07:49:14 +0000

If you’ve ever worked with image uploads in your project, you’ve probably hit one of these pain points:

Cloudinary-style pricing shock (paying for bandwidth + storage separately)
Strict image size caps (10–20MB max on most APIs)
Surprise overage bills when traffic spikes
Auto-deletion of your uploads after a short time

That’s why we built the Simple Image Hosting API — a developer-first solution that’s flat-priced, predictable, and designed for real-world use cases.

👉 Get started instantly on RapidAPI:
Upload Images Hosting API

🖼️ Why This API?

Here’s what sets it apart from other image hosting APIs:

Flat Pricing – Pay per request, no bandwidth billing.
35MB per image – Handle high-res photos, design assets, and screenshots without compression errors.
No Auto-Delete – Unlike “temporary image hosts,” your uploads stay.
Flexible Uploads – Send images via:
- Binary file
- Base64 data
- A URL pointing to the image

⚡ Quick Example (Node.js)

Uploading an image via URL is as simple as one POST request:

const axios = require("axios");

async function uploadImage() {
  const options = {
    method: 'POST',
    url: 'https://upload-images-hosting-get-url.p.rapidapi.com/upload',
    headers: {
      'x-rapidapi-host': 'upload-images-hosting-get-url.p.rapidapi.com',
      'x-rapidapi-key': 'YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    data: {
      url: "https://example.com/your-image.png"
    }
  };

  try {
    const res = await axios.request(options);
    console.log(res.data);
  } catch (err) {
    console.error(err);
  }
}

uploadImage();

Example Response

{
  "data": {
    "id": "Ps9FZHtW",
    "title": "string",
    "url_viewer": "https://ibb.co/Ps9FZHtW",
    "url": "https://i.ibb.co/j9WbvXHw/string.png",
    "display_url": "https://i.ibb.co/CpMm5GW9/string.png",
    "width": 1280,
    "height": 692,
    "size": 96415,
    "time": 1757746440,
    "expiration": 15552000,
    "image": {
      "filename": "string.png",
      "name": "string",
      "mime": "image/png",
      "extension": "png",
      "url": "https://i.ibb.co/j9WbvXHw/string.png"
    },
    "thumb": {
      "filename": "string.png",
      "name": "string",
      "mime": "image/png",
      "extension": "png",
      "url": "https://i.ibb.co/Ps9FZHtW/string.png"
    },
    "medium": {
      "filename": "string.png",
      "name": "string",
      "mime": "image/png",
      "extension": "png",
      "url": "https://i.ibb.co/CpMm5GW9/string.png"
    },
    "delete_url": "https://ibb.co/Ps9FZHtW/9205a77cc5c27603389188d7e0e71df3"
  },
  "success": true,
  "status": 200
}

That’s it — you’ve got a permanent hosted image link ready to embed anywhere.

💸 Pricing (No Surprises)

Unlike Cloudinary/ImageKit (where pricing depends on storage, transformations, and bandwidth), we keep it simple:

Free Tier – Test instantly
Pro / Ultra / Mega – Scale up as you grow

👉 Check plans on RapidAPI here:
Plans up to Mega

👉 Need bigger plans (Biz & Bulk)? They’re available on API Market:
Full Pricing (Biz & Bulk)

🛠️ Perfect Use Cases

High-resolution photography apps
Graphic design & print workflows
SaaS products needing reliable image storage
Developers building social apps, dashboards, or CMS tools
Agencies managing multiple client projects

🚀 Start Free in 30 Seconds

Get your free API key on RapidAPI: Upload Images Hosting API
Make your first request (free tier included).
Scale up when your app is ready.

✅ TL;DR

No bandwidth billing → predictable cost
35 MB limit per image → larger than most providers
Flat per-request pricing → scale without anxiety
Free tier available → try it now

We built this API to give developers a straightforward, no-surprise image hosting option. Whether you’re working on a personal side project or scaling a SaaS product, this API has you covered.

👉 Start free on RapidAPI
👉 View extended plans on API Market

Build Your Own Temp Mail Website in Minutes with This Open-Source Project!

Dishant Singh — Tue, 08 Jul 2025 11:59:01 +0000

Most disposable email services are black boxes. You use the website, the emails appear, you have no idea what is running underneath and no way to customize anything.

FreeCustom.Email is different — there is an open-source project you can deploy as your own temp mail website, and a full API behind it that you can build on top of however you want. This post shows you exactly how to get your own instance running, how to hook into the API for custom functionality, and what you can build from there.

What You Are Actually Building

The open-source project gives you a complete, deployable temp mail frontend that connects to the FreeCustom.Email API. You get:

A working temp mail website with your own branding and domain
Full control over the UI — change anything you want
The same underlying email infrastructure (real SMTP, real delivery, real OTP extraction)
Access to the REST API for any custom features you want to add

You are not reinventing the email infrastructure. You are building a custom interface on top of infrastructure that already works.

Option 1: Use the Open-Source Frontend

FreeCustom.Email provides an open-source project you can clone and deploy. It is a complete temp mail UI that connects to the API.

The full guide with deployment instructions lives at freecustom.email/blog/build-your-own-temp-mail-website.

The basic flow:

# Clone the project
git clone https://github.com/DishIs/temp-mail
cd temp-mail

# Install dependencies
npm install

# Add your API key
cp .env.example .env.local
# Edit .env.local and set FCE_API_KEY=fce_your_key_here

Get your API key by running fce login (install the CLI first) or from the dashboard.

# Start dev server
npm run dev

You now have a running temp mail website at localhost:3000. Deploy it anywhere that runs Next.js — Vercel, Railway, Fly.io, your own VPS.

Option 2: Build From Scratch With the API

If you want more control, the REST API is straightforward. Here is a minimal temp mail app in about 60 lines of JavaScript:

// Simple temp mail app — no framework needed
const FCE_KEY = process.env.FCE_API_KEY;
const BASE = 'https://api2.freecustom.email/v1';

const headers = {
  'Authorization': `Bearer ${FCE_KEY}`,
  'Content-Type': 'application/json',
};

// 1. Create a random inbox
async function createInbox() {
  const res = await fetch(`${BASE}/inboxes`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ inbox: `user-${Date.now()}@ditmail.info` }),
  });
  const { data } = await res.json();
  return data.inbox;
}

// 2. List messages
async function getMessages(inbox) {
  const res = await fetch(`${BASE}/inboxes/${inbox}/messages`, { headers });
  const { data } = await res.json();
  return data ?? [];
}

// 3. Get a single message
async function getMessage(inbox, id) {
  const res = await fetch(`${BASE}/inboxes/${inbox}/messages/${id}`, { headers });
  const { data } = await res.json();
  return data;
}

// 4. Extract OTP (Growth plan+)
async function getOtp(inbox) {
  const res = await fetch(`${BASE}/inboxes/${inbox}/otp`, { headers });
  const { data } = await res.json();
  return data?.otp;
}

// 5. Delete inbox when done
async function deleteInbox(inbox) {
  await fetch(`${BASE}/inboxes/${inbox}`, { method: 'DELETE', headers });
}

That is the full API surface for a basic temp mail app. Five functions covering the whole lifecycle.

Adding Real-Time Email with WebSocket

Polling getMessages() works but feels slow. On Startup plan+, you can push emails to the browser the moment they arrive using the WebSocket endpoint:

// Client-side — connect to the real-time stream
function watchInbox(inbox, onEmail) {
  const ws = new WebSocket(
    `wss://api2.freecustom.email/v1/ws?inbox=${inbox}&api_key=${FCE_KEY}`
  );

  ws.onmessage = (event) => {
    const email = JSON.parse(event.data);
    onEmail(email);
  };

  ws.onclose = () => {
    // Auto-reconnect after 2 seconds
    setTimeout(() => watchInbox(inbox, onEmail), 2000);
  };

  return ws;
}

// Usage
const ws = watchInbox('user@ditmail.info', (email) => {
  console.log('New email:', email.subject);
  renderEmailInUI(email);
});

Emails appear in under 200ms. No polling loop, no refresh button, no delay.

A Minimal React Component

Here is a self-contained React component that gives you a working temp mail UI:

import { useState, useEffect, useCallback } from 'react';

const FCE_BASE = 'https://api2.freecustom.email/v1';
const headers = { 'Authorization': `Bearer ${process.env.NEXT_PUBLIC_FCE_KEY}` };

export function TempMailWidget() {
  const [inbox, setInbox]     = useState<string | null>(null);
  const [messages, setMessages] = useState<any[]>([]);
  const [selected, setSelected] = useState<any | null>(null);
  const [loading, setLoading]  = useState(false);

  // Create inbox on mount
  useEffect(() => {
    const addr = `user-${Date.now()}@ditmail.info`;
    fetch(`${FCE_BASE}/inboxes`, {
      method: 'POST',
      headers: { ...headers, 'Content-Type': 'application/json' },
      body: JSON.stringify({ inbox: addr }),
    }).then(() => setInbox(addr));
  }, []);

  // Real-time WebSocket
  useEffect(() => {
    if (!inbox) return;
    const ws = new WebSocket(
      `wss://api2.freecustom.email/v1/ws?inbox=${inbox}&api_key=${process.env.NEXT_PUBLIC_FCE_KEY}`
    );
    ws.onmessage = (e) => {
      const msg = JSON.parse(e.data);
      setMessages(prev => [msg, ...prev]);
    };
    return () => ws.close();
  }, [inbox]);

  const openMessage = useCallback(async (id: string) => {
    setLoading(true);
    const res = await fetch(`${FCE_BASE}/inboxes/${inbox}/messages/${id}`, { headers });
    const { data } = await res.json();
    setSelected(data);
    setLoading(false);
  }, [inbox]);

  if (!inbox) return <p>Creating inbox…</p>;

  return (
    <div className="temp-mail">
      <div className="inbox-header">
        <code>{inbox}</code>
        <button onClick={() => navigator.clipboard.writeText(inbox)}>Copy</button>
      </div>

      {messages.length === 0 ? (
        <p className="waiting">Waiting for emails…</p>
      ) : (
        <ul className="message-list">
          {messages.map(msg => (
            <li key={msg.id} onClick={() => openMessage(msg.id)}>
              <strong>{msg.from?.name ?? msg.from?.address}</strong>
              <span>{msg.subject}</span>
            </li>
          ))}
        </ul>
      )}

      {selected && (
        <div className="message-body">
          <h3>{selected.subject}</h3>
          <p className="from">From: {selected.from?.address}</p>
          <div dangerouslySetInnerHTML={{ __html: selected.html ?? selected.text }} />
        </div>
      )}
    </div>
  );
}

Style it however you want. The core logic is about 60 lines.

Adding OTP Auto-Extraction to Your UI

This is the feature that users love most. When an email arrives that contains a verification code, surface it immediately:

async function checkForOtp(inbox: string): Promise<string | null> {
  const res = await fetch(
    `https://api2.freecustom.email/v1/inboxes/${inbox}/otp`,
    { headers }
  );
  const { success, data } = await res.json();
  return success ? data?.otp ?? null : null;
}

// In your email display component
const otp = await checkForOtp(inbox);
if (otp) {
  return (
    <div className="otp-banner">
      <span>Verification code:</span>
      <strong>{otp}</strong>
      <button onClick={() => navigator.clipboard.writeText(otp)}>Copy</button>
    </div>
  );
}

The API handles all OTP parsing — numeric codes, alphanumeric tokens, magic links. You just display whatever it returns. OTP extraction is available on Growth plan+.

CLI for Development and Testing

While building, the fce CLI is useful for quickly testing your inboxes without needing to use your UI:

# Install
curl -fsSL freecustom.email/install.sh | sh
fce login

# Watch any inbox in real time
fce watch user-1234567890@ditmail.info

# Check if OTP arrived
fce otp user-1234567890@ditmail.info

────────────────────────────────────────────────
  OTP
────────────────────────────────────────────────

  OTP   ·  212342
  From  ·  noreply@someservice.com
  Subj  ·  Your verification code
  Time  ·  20:19:54

The CLI is MIT-licensed and open source: github.com/DishIs/fce-cli

What You Can Build on Top of This

Once you have the basic UI running, the API opens up a lot of directions:

Custom domain inboxes — on Growth plan, users can receive emails at user@yourdomain.com instead of the default FCE domains. Great for white-labelling.

Saved inboxes — let logged-in users register and keep specific addresses rather than getting a random one every session.

Notification webhooks — call your own endpoint when emails arrive by combining WebSocket with your backend.

Team inboxes — a shared inbox address multiple people on a team can watch, useful for staging environment alerts.

API access for power users — expose the FCE API to your own users with your own rate limits and billing, acting as a reseller layer.

The full-stack guide covers the monetization and multi-tenant patterns in detail if you want to go that route.

The Full API Reference

The complete API is documented at freecustom.email/api/docs and there is an interactive playground at freecustom.email/api/playground. The OpenAPI spec is at freecustom.email/openapi.yaml if you want to generate a client in another language.

The endpoints you will use most:

POST   /v1/inboxes                              Create inbox
GET    /v1/inboxes                              List inboxes
DELETE /v1/inboxes/{inbox}                      Remove inbox
GET    /v1/inboxes/{inbox}/messages             List messages
GET    /v1/inboxes/{inbox}/messages/{id}        Get message
GET    /v1/inboxes/{inbox}/otp                  Extract OTP
WSS    /v1/ws?inbox={inbox}&api_key={key}       Real-time stream
GET    /v1/domains                              Available domains

Auth is Authorization: Bearer fce_your_key on every request.

Pricing

The API is free to start — 5,000 requests per month with no credit card. Paid plans add higher limits, WebSocket delivery, and OTP extraction.

Plan	Price	Req/month	WebSocket	OTP extraction
Free	$0	5,000	✗	✗
Developer	$7/mo	100,000	✗	✗
Startup	$19/mo	500,000	✓	✗
Growth	$49/mo	2,000,000	✓	✓

Full details: freecustom.email/api/pricing

DEV Community: DishIs Technologies

Automating Workflows with Image Hosting API and MCP Servers

Why Use Automations?

Using the API in Automations

Example: Node.js Script for Automated Uploads

Setting Up for MCP Servers

Example MCP Config

Example Workflow in MCP

API Response Example

Conclusion

How to Set Up Our Image Hosting API on Your E-Commerce App or Website

Why Use Our Image Hosting API?

Step 1: Get Your API Key

Step 2: Upload an Image

Step 3: Example API Response

Step 4: Integrate Into Your E-Commerce Workflow

Step 5: Manage Storage and Scaling

Conclusion

🚀 A Simple, Affordable Image Hosting API (35MB per Image, No Bandwidth Limits)

🖼️ Why This API?

⚡ Quick Example (Node.js)

Example Response

💸 Pricing (No Surprises)

🛠️ Perfect Use Cases

🚀 Start Free in 30 Seconds

✅ TL;DR

Build Your Own Temp Mail Website in Minutes with This Open-Source Project!

What You Are Actually Building

Option 1: Use the Open-Source Frontend

Option 2: Build From Scratch With the API

Adding Real-Time Email with WebSocket

A Minimal React Component

Adding OTP Auto-Extraction to Your UI

CLI for Development and Testing

What You Can Build on Top of This

The Full API Reference

Pricing

Links