API Robotext

{
    "status": "completed",
    "message": "Идет подготовка к перефразированию текста, пожалуйста, ожидайте...",
    "job_id": "5036e45d-53f2-4a72-92d2-8d5d79e22a72"
}

{
    "status": "continue",
    "progress": "Нейросеть Robotext перефразирует текст... ✏️",
    "notice": {"type": "generating", "progress": 40}
}

{
    "status": "completed",
    "result_text": [
        "Доброе утро, друзья. Давайте поработаем над этим.",
        "Доброе утро, товарищи! Давайте поработаем над проектами.",
        "Доброе утро, коллеги. Давайте поработаем над проектом!"
    ],
    "sentences_variat": {
        "sentence-1": ["Добрый день, товарищи.", ["Доброе утро, друзья."], ["Доброе утро, коллеги."]]
    },
    "balance_message": "52511 символов",
    "result_len": 78,
    "keys": {}
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: пока эта задача
#    не завершится, новые создавать нельзя.
payload = {
    "api": "1",                                  # обязателен для работы по токену
    "mode": "simple",                            # simple — поверхностное, deep — глубокое
    "html": "Добрый день, товарищи. Давайте займемся проектом.",
}

resp = requests.post(f"{BASE}/create-rewrite-job", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус — не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-rewrite-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        for i, variant in enumerate(data["result_text"], 1):
            print(f"Вариант {i}: {variant}")
        print("Списано символов:", data["result_len"])
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

{
    "status": "completed",
    "message": "Идет подготовка к сокращению текста, пожалуйста, ожидайте...",
    "notice": {"type": "generating"},
    "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341"
}

{
    "status": "continue",
    "progress": "Нейросеть Robotext сокращает текст... ✏️",
    "notice": {"type": "generating", "progress": null}
}

{
    "status": "completed",
    "result_text": "Сокращённый текст.",
    "balance_message": "52011 символов"
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

text = (
    "Искусственный интеллект объединяет в себе несколько научных направлений: "
    "нейронные сети, машинное обучение, обработку естественного языка, когнитивные "
    "вычисления и компьютерное зрение. Однако чёткого представления о том, что именно "
    "входит в понятие искусственного интеллекта, нет, так как нет общепринятых критериев "
    "разумности и соответствия человеческому интеллекту."
) * 3   # исходный текст должен быть не короче 400 символов

# 1. Создаём задачу. В работе может быть только одна задача.
payload = {
    "text": text,
    "requiredLength": "250",     # см. таблицу допустимых значений
    "mode": "whole",
}

resp = requests.post(f"{BASE}/create-reduction-job", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-reduction-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        print("Результат:", data["result_text"])
        print("Баланс:", data["balance_message"])
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

{
    "status": "completed",
    "data": "Сгенерированный текст",
    "job_id": "94d5be99-b9c1-442b-9218-29fc9b3de0b3",
    "balance": "95068 символов"
}

{
    "status": "completed",
    "message": "Идет подготовка к обработке, пожалуйста, ожидайте...",
    "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341"
}

{
    "status": "continue",
    "message": "Нейросеть Robotext генерирует текст... ✏️",
    "notice": {"type": "generating", "seconds": 30}
}

{
    "status": "completed",
    "result": "Сгенерированный текст",
    "result_len": 1024,
    "balance": "95068 символов"
}

import json
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# is_stream=0 — получить готовый текст одним ответом.
# Тело обязательно form-encoded: в JSON параметр is_stream не читается.
payload = {
    "is_stream": "0",
    "text": "Напиши историю о путешествии на Байкал",
}

resp = requests.post(
    f"{BASE}/create-write-sync/text-generator",
    headers=headers,
    data=payload,
    timeout=180,          # генерация длинного текста занимает время
)
resp.raise_for_status()

# Ошибки приходят с техническим суффиксом-разделителем — отбрасываем его.
body = resp.text.split("--END--")[0]
data = json.loads(body)

if data["status"] == "error":
    raise SystemExit(data.get("data") or data.get("message"))

print(data["data"])
print("Баланс:", data["balance"])

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: в работе только одна задача,
#    новый запрос до её завершения будет отклонён.
payload = {
    "radio": "value1",                 # value1 — задаём тему, value2 — первую строчку
    "keys": "Осень в горах",           # не длиннее 80 символов
}

resp = requests.post(f"{BASE}/create-write-job/poem", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]

# 2. Опрашиваем статус не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-write-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        print(data["result"])                     # в асинхронном ответе поле result
        print("Символов:", data["result_len"])
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

{
    "status": "completed",
    "message": "Идет подготовка к обработке, пожалуйста, ожидайте...",
    "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341"
}

{
    "status": "continue",
    "message": "Нейросеть Robotext генерирует изображение... 🖌️",
    "notice": {"type": "generating", "seconds": 10}
}

{
    "status": "completed",
    "result": "ef3d4aa6-169a-470e-9814-cd93de65c341",
    "balance": "106 🖼️"
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: пока эта задача
#    не завершится, новые запросы будут отклонены.
payload = {
    "text": "Девушка гуляет по новогодней Москве",
    "aspect": "1x1",          # формат из таблицы форматов
    "style": "nostyle",       # стиль из таблицы стилей
}

resp = requests.post(f"{BASE}/create-image-job", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-image-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        image_id = data["result"]        # совпадает с job_id
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

# 3. Скачиваем изображение — обязательно с токеном.
img = requests.get(f"{BASE}/im/{image_id}.png", headers=headers)
img.raise_for_status()

with open("image.png", "wb") as f:
    f.write(img.content)

print("Изображение сохранено в image.png")

{
    "status": "completed",
    "job_id": "3d1f8c2b-7a45-4e19-b0d3-6f2a9c81e5b7",
    "image_url": "https://robotext.io/ime/3d1f8c2b-7a45-4e19-b0d3-6f2a9c81e5b7.png",
    "balance": 4500
}

import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# Запрос синхронный: обработанное фото возвращается сразу.
# Очереди на стороне сервиса нет — в работе может быть только одна задача.
with open("product.jpg", "rb") as f:
    resp = requests.post(
        f"{BASE}/image-edit/process",
        headers=headers,
        files=[("images", f)],          # для нескольких фото повторите поле images
        data={
            "page": "udalit-fon-tovara",
            "background": "transparent",   # transparent | white
        },
        timeout=180,
    )

resp.raise_for_status()
data = resp.json()

if data["status"] == "error":
    raise SystemExit(data.get("message"))

# Результат скачиваем по ссылке из ответа — тоже с токеном.
image = requests.get(data["image_url"], headers=headers)
image.raise_for_status()

with open("result.png", "wb") as f:
    f.write(image.content)

print("Готово, сохранено в result.png. Остаток символов:", data["balance"])

{
    "status": "completed",
    "text": "Полный текст ответа модели",
    "job_id": "0f4c8e2a-6b1d-4f77-9c3e-2a5b7d8e1f04",
    "balance": 4500
}

import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# Запрос синхронный: ответ приходит сразу, опрашивать статус не нужно.
# В работе может быть только одна задача — дождитесь ответа перед следующим запросом.
with open("photo.jpg", "rb") as f:
    resp = requests.post(
        f"{BASE}/ocr/process",
        headers=headers,
        files={"image": f},
        data={
            "page": "raspoznat-tekst-s-foto",
            # "query": "Извлеки только числа из таблицы",   # необязательный свой запрос
        },
        timeout=180,
    )

resp.raise_for_status()
data = resp.json()

if data["status"] == "error":
    raise SystemExit(data.get("message"))

print(data["text"])
print("Остаток символов:", data["balance"])

{
    "status": "completed",
    "message": "Подготовка к генерации примера",
    "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341"
}

{
    "status": "continue",
    "message": "Генерация слайда 4/10",
    "progress": 38,
    "notice": {"type": "generating", "progress": 38, "label": "Генерация слайда 4/10"}
}

{
    "status": "completed",
    "result": {
        "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341",
        "title": "Дореволюционная Москва"
    },
    "balance": "5 🖥"
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: в работе только одна задача.
payload = {
    "topic": "Дореволюционная Москва",   # либо text — готовый текст до 24 000 символов
    "slide_count": "10",                 # 10, 15 или 20
    "template": "organic",               # basic | organic | color | modern | black | plain
}

resp = requests.post(f"{BASE}/create-presentation-job", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-presentation-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        print("Готово:", data["result"]["title"])
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

    print("Прогресс:", data.get("progress"), data.get("message"))

# 3. Скачиваем оба формата — обязательно с токеном.
for fmt in ("pptx", "pdf"):
    file_resp = requests.get(
        f"{BASE}/download-presentation",
        headers=headers,
        params={"job_id": job_id, "format": fmt},
    )
    file_resp.raise_for_status()

    with open(f"presentation.{fmt}", "wb") as f:
        f.write(file_resp.content)

    print(f"Сохранено: presentation.{fmt}")

{
    "status": "completed",
    "message": "Подготовка к генерации",
    "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341"
}

{
    "status": "continue",
    "message": "Генерация песни",
    "progress": 57,
    "notice": {"type": "generating", "progress": 57, "label": "Генерация песни"}
}

{
    "status": "completed",
    "result": {
        "job_id": "ef3d4aa6-169a-470e-9814-cd93de65c341",
        "title": "Моя первая песня",
        "audio_data": "https://s3.timeweb.cloud/2b659743-song100/...",
        "video_data": "https://s3.timeweb.cloud/2b659743-song100/..."
    },
    "balance": "5 🎶"
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: в работе только одна задача.
payload = {
    "preset_style": "__custom__",        # либо готовый пресет, например "Поп"
    "genre": "поп, данс-поп, яркие синты, бодрый хит, 115 bpm",
    "title": "Моя первая песня",         # 3–50 символов
    "text": "Один два три четыре пять\nШесть семь восемь девять десять",
    "vocals": "female",                  # random | female | male | none
    "time_period": "60",                 # секунды, 30–240
    "format_file": "mp3",                # mp3 | wav
}

resp = requests.post(f"{BASE}/create-song-job", headers=headers, data=payload)
resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус не чаще одного раза в секунду.
while True:
    time.sleep(1)

    ping = requests.get(f"{BASE}/ping-song-job", params={"job_id": job_id})
    ping.raise_for_status()
    data = ping.json()

    if data["status"] == "completed":
        print("Готово:", data["result"]["title"])
        break

    if data["status"] == "error":
        raise SystemExit(data.get("message"))

    print("Прогресс:", data.get("progress"))

# 3. Скачиваем файл через эндпоинт с токеном — эта ссылка не истекает,
#    в отличие от audio_data (она действует 1 час).
song = requests.get(
    f"{BASE}/download-song",
    headers=headers,
    params={"job_id": job_id, "format": "mp3"},
)
song.raise_for_status()

with open("song.mp3", "wb") as f:
    f.write(song.content)

print("Песня сохранена в song.mp3")

{
    "status": "completed",
    "message": "Подготовка к генерации",
    "job_id": "8ac2f1e0-3d54-4b8a-9e17-c05f2b6d4a93"
}

{
    "status": "continue",
    "message": "Генерация видео",
    "progress": 42,
    "notice": {"type": "generating", "progress": 42, "label": "Генерация видео"}
}

{
    "status": "completed",
    "balance": "5 🎬",
    "result": {
        "job_id": "8ac2f1e0-3d54-4b8a-9e17-c05f2b6d4a93",
        "video_url": "/vid/8ac2f1e0-3d54-4b8a-9e17-c05f2b6d4a93.mp4",
        "seconds": 8,
        "width": 1344,
        "height": 768,
        "seed": 1837462913,
        "demo": false
    }
}

import time
import requests

TOKEN = "ВАШ_API_ТОКЕН"
BASE = "https://robotext.io"
headers = {"Authorization": f"Bearer {TOKEN}"}

# 1. Создаём задачу. Очереди на стороне сервиса нет: в работе только одна задача,
#    новый запрос до её завершения будет отклонён.
data = {
    "page": "foto-v-video",
    "query": "Камера медленно приближается, лёгкий ветер колышет листву",
    "seconds": "8",              # 4–12
    "resolution": "16x9",        # либо auto — по пропорциям фото
}

with open("photo.jpg", "rb") as f:
    resp = requests.post(
        f"{BASE}/create-video-job",
        headers=headers,
        files=[("images", f)],   # для генерации по одному тексту фото можно не передавать
        data=data,
    )

resp.raise_for_status()
created = resp.json()
if created.get("status") == "error":
    raise SystemExit(created.get("message"))

job_id = created["job_id"]
print("Задача создана:", job_id)

# 2. Опрашиваем статус не чаще одного раза в секунду.
#    Генерация занимает от одной до нескольких минут.
while True:
    time.sleep(1)

    ping = requests.get(
        f"{BASE}/ping-video-job",
        headers=headers,
        params={"job_id": job_id},
    )
    ping.raise_for_status()
    status = ping.json()

    if status["status"] == "completed":
        result = status["result"]
        print("Готово:", result["width"], "x", result["height"], result["seconds"], "сек")
        break

    if status["status"] == "error":
        raise SystemExit(status.get("message"))

    print("Прогресс:", status.get("progress"), status.get("message"))

# 3. Скачиваем ролик — обязательно с токеном.
video = requests.get(
    f"{BASE}{result['video_url']}",
    headers=headers,
    params={"download": "1"},
    stream=True,
)
video.raise_for_status()

with open("video.mp4", "wb") as f:
    for chunk in video.iter_content(chunk_size=256 * 1024):
        f.write(chunk)

print("Видео сохранено в video.mp4")