Text to speech and voice cloning, over HTTP

curl -X POST "https://fsmb616.com/v1/text-to-speech/" \
  -H "xi-api-key: YOUR_API_KEY" \
  -F "text=Hello from FSMB" \
  -F "voice_id=minimax_209533299589198" \
  -F "speed=1" \
  -F "receive_url=https://your-site.com/fsmb-webhook"

import requests

r = requests.post(
    "https://fsmb616.com/v1/text-to-speech/",
    headers={"xi-api-key": "YOUR_API_KEY"},
    data={
        "text": "Hello from FSMB",
        "voice_id": "minimax_209533299589198",
        "speed": "1",
        "receive_url": "https://your-site.com/fsmb-webhook",  # optional
    },
    timeout=30,
)
print(r.status_code, r.json())

const form = new FormData();
form.append("text", "Hello from FSMB");
form.append("voice_id", "minimax_209533299589198");
form.append("speed", "1");
form.append("receive_url", "https://your-site.com/fsmb-webhook"); // optional

const res = await fetch("https://fsmb616.com/v1/text-to-speech/", {
  method: "POST",
  headers: { "xi-api-key": "YOUR_API_KEY" },
  body: form,
});
console.log(res.status, await res.json());

<?php
$ch = curl_init("https://fsmb616.com/v1/text-to-speech/");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => [
        "text"        => "Hello from FSMB",
        "voice_id"    => "minimax_209533299589198",
        "speed"       => "1",
        "receive_url" => "https://your-site.com/fsmb-webhook", // optional
    ],
    CURLOPT_HTTPHEADER     => ["xi-api-key: YOUR_API_KEY"],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
echo curl_exec($ch);
curl_close($ch);

curl "https://fsmb616.com/v1/tasks/?id=TASK_ID" \
  -H "xi-api-key: YOUR_API_KEY"

import requests

s = requests.get(
    "https://fsmb616.com/v1/tasks/",
    headers={"xi-api-key": "YOUR_API_KEY"},
    params={"id": "TASK_ID"},
    timeout=30,
).json()
print(s["status"], s.get("audio_url"))

const res = await fetch("https://fsmb616.com/v1/tasks/?id=TASK_ID", {
  headers: { "xi-api-key": "YOUR_API_KEY" },
});
const s = await res.json();
console.log(s.status, s.audio_url);

<?php
$ch = curl_init("https://fsmb616.com/v1/tasks/?id=" . urlencode("TASK_ID"));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ["xi-api-key: YOUR_API_KEY"],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$s = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $s["status"] ?? "unknown";

from flask import Flask, request
import requests

app = Flask(__name__)
API = "https://fsmb616.com/v1"
HEADERS = {"xi-api-key": "YOUR_API_KEY"}

@app.post("/fsmb-webhook")
def fsmb_webhook():
    task_id = (request.get_json(silent=True) or {}).get("task_id", "")
    # Do not trust the payload on its own: confirm the result with the API.
    s = requests.get(f"{API}/tasks/", headers=HEADERS, params={"id": task_id}, timeout=30).json()
    if s.get("status") == "done":
        print("audio ready:", s["audio_url"])   # download and store it here
    elif s.get("status") == "failed":
        print("task failed:", task_id)
    return "", 204

const express = require("express");
const app = express();
app.use(express.json());

app.post("/fsmb-webhook", async (req, res) => {
  const taskId = (req.body && req.body.task_id) || "";
  res.sendStatus(204); // answer quickly, then confirm the result with the API

  const r = await fetch(`https://fsmb616.com/v1/tasks/?id=${encodeURIComponent(taskId)}`, {
    headers: { "xi-api-key": process.env.FSMB_API_KEY },
  });
  const s = await r.json();
  if (s.status === "done") console.log("audio ready:", s.audio_url); // download and store it
  if (s.status === "failed") console.log("task failed:", taskId);
});

app.listen(3000);

<?php
$payload = json_decode(file_get_contents("php://input"), true);
$taskId  = is_array($payload) ? (string)($payload["task_id"] ?? "") : "";
http_response_code(204);

// Confirm the result with the API instead of trusting the payload alone.
$ch = curl_init("https://fsmb616.com/v1/tasks/?id=" . urlencode($taskId));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ["xi-api-key: YOUR_API_KEY"],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$status = json_decode(curl_exec($ch), true);
curl_close($ch);

if (($status["status"] ?? "") === "done") {
    // download $status["audio_url"] and store it
}

curl "https://fsmb616.com/v1/voices/?provider=minimax&page=1&page_size=20" \
  -H "xi-api-key: YOUR_API_KEY"

import requests

r = requests.get(
    "https://fsmb616.com/v1/voices/",
    headers={"xi-api-key": "YOUR_API_KEY"},
    params={"provider": "minimax", "page": 1, "page_size": 20},
    timeout=30,
)
for v in r.json()["data"]:
    print(v["voice_id"], v["name"])

const url = "https://fsmb616.com/v1/voices/?provider=minimax&page=1&page_size=20";
const res = await fetch(url, { headers: { "xi-api-key": "YOUR_API_KEY" } });
const body = await res.json();
for (const v of body.data) console.log(v.voice_id, v.name);

<?php
$ch = curl_init("https://fsmb616.com/v1/voices/?provider=minimax&page=1&page_size=20");
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ["xi-api-key: YOUR_API_KEY"],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$body = json_decode(curl_exec($ch), true);
curl_close($ch);
foreach ($body["data"] ?? [] as $v) {
    echo $v["voice_id"] . " " . $v["name"] . "\n";
}

curl -X POST "https://fsmb616.com/v1/text-to-speech/voice-clone/" \
  -H "xi-api-key: YOUR_API_KEY" \
  -F "name=My Voice" \
  -F "files=@sample.mp3"

import requests

with open("sample.mp3", "rb") as f:
    r = requests.post(
        "https://fsmb616.com/v1/text-to-speech/voice-clone/",
        headers={"xi-api-key": "YOUR_API_KEY"},
        data={"name": "My Voice"},
        files={"files": ("sample.mp3", f, "audio/mpeg")},
        timeout=180,
    )
print(r.status_code, r.json())

const { readFile } = require("node:fs/promises");

async function cloneVoice() {
  const form = new FormData();
  form.append("name", "My Voice");
  form.append("files", new Blob([await readFile("sample.mp3")], { type: "audio/mpeg" }), "sample.mp3");

  const res = await fetch("https://fsmb616.com/v1/text-to-speech/voice-clone/", {
    method: "POST",
    headers: { "xi-api-key": "YOUR_API_KEY" },
    body: form,
  });
  console.log(res.status, await res.json());
}

cloneVoice();

<?php
$ch = curl_init("https://fsmb616.com/v1/text-to-speech/voice-clone/");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => [
        "name"  => "My Voice",
        "files" => new CURLFile("sample.mp3", "audio/mpeg", "sample.mp3"),
    ],
    CURLOPT_HTTPHEADER     => ["xi-api-key: YOUR_API_KEY"],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 180,
]);
echo curl_exec($ch);
curl_close($ch);

import time
import requests

API = "https://fsmb616.com/v1"
HEADERS = {"xi-api-key": "YOUR_API_KEY"}


def text_to_mp3(text, voice_id, out_path, timeout=180):
    r = requests.post(
        f"{API}/text-to-speech/",
        headers=HEADERS,
        data={"text": text, "voice_id": voice_id, "speed": "1"},
        timeout=30,
    )
    body = r.json()
    if not body.get("success"):
        raise RuntimeError(body)
    task_id = body["task_id"]

    deadline = time.time() + timeout
    while time.time() < deadline:
        s = requests.get(f"{API}/tasks/", headers=HEADERS, params={"id": task_id}, timeout=30).json()
        if s.get("status") == "done":
            audio = requests.get(s["audio_url"], timeout=120)
            audio.raise_for_status()
            with open(out_path, "wb") as f:
                f.write(audio.content)
            return out_path
        if s.get("status") == "failed":
            raise RuntimeError(f"Task {task_id} failed")
        time.sleep(4)
    raise TimeoutError(f"Task {task_id} is still processing")


text_to_mp3("Hello from FSMB.", "minimax_209533299589198", "hello.mp3")

const { writeFile } = require("node:fs/promises");

const API = "https://fsmb616.com/v1";
const KEY = process.env.FSMB_API_KEY;
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function textToMp3(text, voiceId, outPath) {
  const form = new FormData();
  form.append("text", text);
  form.append("voice_id", voiceId);
  form.append("speed", "1");

  const submit = await (
    await fetch(`${API}/text-to-speech/`, {
      method: "POST",
      headers: { "xi-api-key": KEY },
      body: form,
    })
  ).json();
  if (!submit.success) throw new Error(JSON.stringify(submit));

  const deadline = Date.now() + 180000;
  while (Date.now() < deadline) {
    const res = await fetch(`${API}/tasks/?id=${submit.task_id}`, { headers: { "xi-api-key": KEY } });
    const s = await res.json();
    if (s.status === "done") {
      const audio = await fetch(s.audio_url);
      await writeFile(outPath, Buffer.from(await audio.arrayBuffer()));
      return outPath;
    }
    if (s.status === "failed") throw new Error(`Task ${submit.task_id} failed`);
    await sleep(4000);
  }
  throw new Error("Timed out waiting for audio");
}

textToMp3("Hello from FSMB.", "minimax_209533299589198", "hello.mp3").then(console.log);

# app.py  -  install:  pip install flask requests
# run:  FSMB_API_KEY=your_key flask run
import os
import re

import requests
from flask import Flask, jsonify, request

app = Flask(__name__)

API = "https://fsmb616.com/v1"
KEY = os.environ["FSMB_API_KEY"]   # the key lives only here, never in page code
HEADERS = {"xi-api-key": KEY}
MAX_TEXT = 2000                    # your own limit per request


def forward(response):
    try:
        data = response.json()
    except ValueError:
        return jsonify(error="Bad response"), 502
    return jsonify(data), response.status_code


@app.post("/api/tts")
def tts():
    body = request.get_json(silent=True) or {}
    text = str(body.get("text", "")).strip()
    voice_id = str(body.get("voice_id", "minimax_209533299589198"))
    if not text or len(text) > MAX_TEXT:
        return jsonify(error="Text is empty or too long"), 400
    if not re.fullmatch(r"[A-Za-z0-9_.\-]{1,120}", voice_id):
        return jsonify(error="Invalid voice"), 400
    try:
        r = requests.post(
            f"{API}/text-to-speech/",
            headers=HEADERS,
            data={"text": text, "voice_id": voice_id, "speed": "1"},
            timeout=30,
        )
    except requests.RequestException:
        return jsonify(error="Service unavailable, please try again"), 502
    return forward(r)


@app.get("/api/task")
def task():
    task_id = request.args.get("id", "")
    if not re.fullmatch(r"[A-Za-z0-9\-]{36}", task_id):
        return jsonify(error="Invalid task id"), 400
    try:
        r = requests.get(f"{API}/tasks/", headers=HEADERS, params={"id": task_id}, timeout=30)
    except requests.RequestException:
        return jsonify(error="Service unavailable, please try again"), 502
    return forward(r)

// server.js  -  run:  FSMB_API_KEY=your_key node server.js   (Node 18 or newer, no packages needed)
const http = require("node:http");

const API = "https://fsmb616.com/v1";
const KEY = process.env.FSMB_API_KEY;   // the key lives only here, never in page code
const MAX_TEXT = 2000;                  // your own limit per request

if (!KEY) {
  console.error("Set FSMB_API_KEY first.");
  process.exit(1);
}

function send(res, status, body) {
  res.writeHead(status, { "Content-Type": "application/json" });
  res.end(JSON.stringify(body));
}

function readJson(req) {
  return new Promise((resolve, reject) => {
    let raw = "";
    let tooBig = false;
    req.on("data", (chunk) => {
      if (raw.length < 20000) raw += chunk;
      else tooBig = true;
    });
    req.on("end", () => {
      if (tooBig) return reject(new Error("too large"));
      try { resolve(JSON.parse(raw || "{}")); } catch (e) { reject(e); }
    });
    req.on("error", reject);
  });
}

http.createServer(async (req, res) => {
  try {
    const url = new URL(req.url, "http://localhost");

    if (req.method === "POST" && url.pathname === "/api/tts") {
      let body;
      try { body = await readJson(req); } catch { return send(res, 400, { error: "Invalid request" }); }
      const text = String(body.text || "").trim();
      const voiceId = String(body.voice_id || "minimax_209533299589198");
      if (!text || text.length > MAX_TEXT) return send(res, 400, { error: "Text is empty or too long" });
      if (!/^[A-Za-z0-9_.\-]{1,120}$/.test(voiceId)) return send(res, 400, { error: "Invalid voice" });

      const form = new FormData();
      form.append("text", text);
      form.append("voice_id", voiceId);
      form.append("speed", "1");
      const r = await fetch(`${API}/text-to-speech/`, {
        method: "POST",
        headers: { "xi-api-key": KEY },
        body: form,
      });
      return send(res, r.status, await r.json().catch(() => ({ error: "Bad response" })));
    }

    if (req.method === "GET" && url.pathname === "/api/task") {
      const id = url.searchParams.get("id") || "";
      if (!/^[A-Za-z0-9\-]{36}$/.test(id)) return send(res, 400, { error: "Invalid task id" });
      const r = await fetch(`${API}/tasks/?id=${encodeURIComponent(id)}`, {
        headers: { "xi-api-key": KEY },
      });
      return send(res, r.status, await r.json().catch(() => ({ error: "Bad response" })));
    }

    send(res, 404, { error: "Not found" });
  } catch {
    send(res, 502, { error: "Service unavailable, please try again" });
  }
}).listen(3000, () => console.log("Listening on http://localhost:3000"));

<?php
// ---------- File 1: api/tts.php ----------
// Keep the key outside your web folder, for example in an environment variable
// or in a file such as /home/youruser/fsmb_key.php that contains:  <?php $FSMB_KEY = "your_key";
$KEY = getenv("FSMB_API_KEY");
header("Content-Type: application/json");

$in    = json_decode(file_get_contents("php://input"), true);
$text  = trim((string)($in["text"] ?? ""));
$voice = (string)($in["voice_id"] ?? "minimax_209533299589198");

if ($text === "" || mb_strlen($text) > 2000) {
    http_response_code(400);
    echo json_encode(["error" => "Text is empty or too long"]);
    exit;
}
if (!preg_match('/^[A-Za-z0-9_.\-]{1,120}$/', $voice)) {
    http_response_code(400);
    echo json_encode(["error" => "Invalid voice"]);
    exit;
}

$ch = curl_init("https://fsmb616.com/v1/text-to-speech/");
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => ["text" => $text, "voice_id" => $voice, "speed" => "1"],
    CURLOPT_HTTPHEADER     => ["xi-api-key: " . $KEY],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$out  = curl_exec($ch);
$code = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($out === false || $code === 0) {
    http_response_code(502);
    echo json_encode(["error" => "Service unavailable, please try again"]);
    exit;
}
http_response_code($code);
echo $out;

<?php
// ---------- File 2: api/task.php ----------
$KEY = getenv("FSMB_API_KEY");
header("Content-Type: application/json");

$id = (string)($_GET["id"] ?? "");
if (!preg_match('/^[A-Za-z0-9\-]{36}$/', $id)) {
    http_response_code(400);
    echo json_encode(["error" => "Invalid task id"]);
    exit;
}

$ch = curl_init("https://fsmb616.com/v1/tasks/?id=" . urlencode($id));
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER     => ["xi-api-key: " . $KEY],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
]);
$out  = curl_exec($ch);
$code = (int)curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($out === false || $code === 0) {
    http_response_code(502);
    echo json_encode(["error" => "Service unavailable, please try again"]);
    exit;
}
http_response_code($code);
echo $out;