DEV Community: DishIs Technologies

Your captcha token was solved but the site still rejected it: 7 causes and fixes

Dishant Singh — Wed, 21 Oct 2026 17:08:14 +0000

You automated the boring part. The solver returned a token, you dropped it into the form, you hit submit, and the site came back with "verification failed". No stack trace, no useful error, just a page that looks exactly like the one you started on.

This happens to everyone who automates anything behind a captcha, whether it's an end-to-end test suite for your own signup flow, a monitoring job, or an agent that fills in forms. The token itself is rarely "wrong". Almost always, it's valid but used in a way the site's backend refuses.

Here are the seven causes I see most often, roughly in order of how often they bite, and what to do about each one.

1. The token expired before you submitted it

Captcha tokens are short-lived on purpose.

reCAPTCHA: Google's docs say each response token "is valid for two minutes, and can only be verified once."
Cloudflare Turnstile: tokens are valid for 300 seconds (five minutes) after they're generated.

Two minutes sounds like plenty until you look at what a real script does between "token received" and "form submitted": it waits for a page to settle, fills ten other fields, uploads a file, retries a flaky selector. If your flow takes 90 seconds before it even asks for the token, you're cutting it close.

Fix: request the token as late as possible, right before submit. Don't fetch it at the start of the test "to have it ready". If your form has a long multi-step flow, fill everything else first and solve the captcha last.

2. You used the same token twice

Both Google and Cloudflare reject a token the second time it's verified. On the server side this shows up as timeout-or-duplicate, and both vendors use that same code for "too old" and "already used", which is why it's so confusing.

The classic way to hit this: a retry loop. The submit fails for an unrelated reason (a validation error on another field, a 502 from the backend), your code retries the submit, and the retry carries the token that the first attempt already burned.

Fix: treat a token as single-use in your code too. If you retry a submit, get a fresh token for the retry.

3. The sitekey or page URL doesn't match the page you're on

A token is tied to the sitekey it was issued for and to the site it was solved on. Google returns a hostname field in the verification response so the site can check where the challenge was solved.

Two ways this goes wrong:

Wrong sitekey. Many sites have more than one: a staging key and a production key, or a separate key for the login page and the checkout page. Scrape the data-sitekey from the exact page you're submitting, not from a config file you copied last month.
Wrong URL. Send the full URL of the page where the captcha actually appears, not the site's homepage. For an SPA, that's the route the widget renders on.

4. reCAPTCHA v3: wrong action, or a score below the site's threshold

v3 doesn't show a challenge. It returns a score between 0.0 and 1.0, and Google's own guidance is that "by default, you can use a threshold of 0.5". Each site picks its own threshold, and it can be stricter on sensitive pages.

v3 also has actions. Google tells site owners to "verify that the action name is the name you expect". If the page calls grecaptcha.execute(key, { action: 'login' }) and your token was generated for submit or no action at all, a careful backend will reject it even with a decent score.

Fix: read the action name from the page's own JavaScript (search the bundle for execute() and pass it through when you request the token. Only ask for a minimum score as high as the site actually needs. If you want the longer version, including why free keys only ever return 0.1, 0.3, 0.7 or 0.9, I wrote up how reCAPTCHA v3 scores work.

5. The token was earned by a different browser than the one submitting it

This is the one that catches people with Turnstile and with anti-bot vendors like DataDome. The token or cookie is minted in one browser context (one IP address, one user agent) and then submitted from another.

If you solve through a remote service, pass your own proxy so the solve happens from the same IP your script uses.
Pass the same user agent your browser uses, or, if the solver hands back the user agent it used, set your browser to that one before submitting.

Fix: keep the IP and user agent consistent between "earn the token" and "use the token". For DataDome you'll get a cookie rather than a token; set it on the same session and keep using the same proxy. (More on what Turnstile actually checks in How Cloudflare Turnstile works.)

6. You put the token in the wrong place

Each widget expects the token in a specific spot:

reCAPTCHA v2 and v3: a hidden textarea named g-recaptcha-response.
Turnstile: a hidden input named cf-turnstile-response.

Many modern sites don't read that field at all. They register a JavaScript callback (data-callback="onSolved") and only enable the submit button, or only attach the token to their fetch request, when that callback fires. Setting the field's value does nothing if the callback never runs.

Fix: check the widget's data-callback attribute. If there is one, call that function with the token after you set the field (this is Puppeteer/Playwright-style; there's a full Playwright example if you need the surrounding code):

await page.evaluate((token) => {
  document.querySelector('[name="g-recaptcha-response"]').value = token;
  const cb = document.querySelector('[data-sitekey]')?.getAttribute('data-callback');
  if (cb && typeof window[cb] === 'function') window[cb](token);
}, token);

7. It's reCAPTCHA Enterprise, not classic reCAPTCHA

Enterprise keys look the same but load from recaptcha/enterprise.js and are verified through a different API. A token solved as classic v2 or v3 won't pass an Enterprise check.

Fix: look at the script tag. If you see enterprise.js, or calls to grecaptcha.enterprise.execute, tell your solver it's Enterprise.

A quick checklist before you blame the solver

Am I requesting the token right before submit?
Does every retry get a fresh token?
Is the sitekey from this exact page, and am I sending this exact URL?
For v3: the right action, and a score the site will accept?
Same IP and user agent for solving and submitting?
Is the token in the right field, and did the callback fire?
Is it actually Enterprise?

How we handle this at CaptchaNo

Full disclosure: I work on CaptchaNo, a captcha solving API, and several of these causes shaped how the API works. One request covers reCAPTCHA v2, v3 and Enterprise, Turnstile, DataDome and image captchas. The call waits for the token instead of making you poll, which helps with cause #1. You can pass proxy, userAgent, action and minScore for causes #4 and #5, and failed solves aren't billed. The API reference has the full request format, and there's an open-source MCP server if your automation is an AI agent. Even if you use something else, the checklist above applies to every solver. If you're comparing services, I also wrote a guide to choosing a captcha solving API.

Whatever you're automating, keep it to things you're allowed to automate: your own sites, systems you have permission to test, and data collection the site's terms permit.

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

Your captcha token was solved but the site still rejected it: 7 causes and fixes

1. The token expired before you submitted it

2. You used the same token twice

3. The sitekey or page URL doesn't match the page you're on

4. reCAPTCHA v3: wrong action, or a score below the site's threshold

5. The token was earned by a different browser than the one submitting it

6. You put the token in the wrong place

7. It's reCAPTCHA Enterprise, not classic reCAPTCHA

A quick checklist before you blame the solver

How we handle this at CaptchaNo

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