The guide

Nothing here needs code. You sign in and make an agent; the models are ready.

1. Sign in, or create your account. Press Get started. Sign in with email and password, Apple or Google — or press Create an account and enter your name, email, a password, and your role: creator, small business, educator, researcher, or other. The role shapes the first suggestions you see; you can change it later. You start with an empty canvas.
2. Check your credits. Open the profile menu (bottom left) → Billing. The included model is free; every other model runs on credits, at the price listed there. Premium includes credits each month, and you can add more at any time.
3. Create an agent. Press New agent (bottom right of the canvas) and say what you want in your own words — "Turn new blog posts into LinkedIn posts". The agents are built on your canvas as you watch, each with its Input, Prompt and Output; the one being made is outlined in blue. They are saved as drafts, and nothing runs until you run it. Open one to check it, or ask in the chat for a change.
4. Process, read, submit. Press Process. The result appears as a draft. Read it, edit it by hand if you want, and submit it — that sends it to the output. If it isn't right, change the prompt and Process again instead.
5. Save and set the trigger. Save activates the agent in full. On the input, choose Manually, Daily or On update. Daily and On update send without you from then on.

Open any agent and you see three columns: Input, Prompt and Output. That is the whole agent.

• Input is a source the agent reads — an Apify scrape, an X account, an Ebiblo input page, an Emidox storage source — with files attached if you want. Sources covers each one.
• Prompt is what you want done with it, in three parts: a description, an instruction and examples. Prompts explains how to write each.
• Output is a source the result goes to — LinkedIn, X, Telegram, email, an Ebiblo quiz page, or Emidox storage for the next agent. Where the result goes.

Above the columns are the agent's name and model. The name is yours; use the job, not the tool ("Morning posts", not "LinkedIn agent"). The model is the AI that runs the prompt, chosen per agent, with its price beside it.

At the bottom are three controls, and they are the heart of it:

• Process runs the prompt once, now, on what the input currently holds. Nothing is sent.
• Draft is where the result lands. You read it as the person receiving it would, and you can edit it by hand — cut a line, fix a claim, change the tone. When it reads right, submit it and it goes to the output. That is publishing, and it is always a person's decision on a manual run.
• Save saves the agent and activates its features in full — including its trigger, so a Daily or On-update agent starts sending on its own.

The canvas — the home screen — shows every agent as a row of three nodes with wires between them, and where agents are chained it shows the chain. Zoom and lock controls are at the bottom left.

Every input and output in Emidox is a source. Press + in the left rail to add one; the list is Emidox, Email, Ebiblo, Apify, LinkedIn, X.com and Telegram. A source appears in the Sources panel, and each kind goes in one column or the other — the app only lets you drop it where it belongs.

• Apify — input. A scraper you already run on Apify. Its results land as a source that grows with each run; the usual choice for anything that starts on the web.
• X.com — input and output. As an input, your account's comments, posts and reposts. As an output, publishing.
• Ebiblo — two kinds. An input page (input column) is a page with a public link where a person types, speaks or drops files — it has a title, a sender name, a description and a transcription model for speech. A quiz page (output column) is where a result lands as a question set in Ebiblo. Together they are how Ebiblo runs on Emidox.
• Emidox — input or output. A storage source that holds data between agents: one agent writes to it, the next reads from it. This is how chains pass work along.
• Email, LinkedIn, Telegram — output only. See where the result goes.

Files can be attached to any input source — documents, spreadsheets, images, whatever the model can read.

Use data from follows the trigger: a manual run uses the most recent update, a daily run uses everything sent to the agent in the last 24 hours, and on update handles each item as it arrives.

A prompt has three boxes. They are not decoration; the model treats them differently.

• Description — one paragraph on what this agent is for and what a good result looks like. Write it the way you'd brief a person on their first day.
• Instruction — the rules. What to do with each input, what to produce, what to leave out, what to do when unsure. Headings and numbered steps work well here; the model follows structure.
• Examples — two or three real inputs with the output you'd want for each. Examples do more than any adjective in the instruction. If you have none, Process once, edit the draft by hand into what you wanted, and paste that pair in.

The rule that earns its place in almost every prompt: if you are not sure, leave it out and say so. It turns a confident wrong claim into a line you can read in ten seconds.

A prompt library — prompts that keep working, kept in one place to reuse across agents — is coming. For now the pattern is to duplicate a saved agent and change its input.

Emidox is not tied to one AI. The model picker on every agent lists OpenAI, Anthropic (Claude), Google (Gemini), DeepSeek, xAI (Grok) and Moonshot (Kimi), beside Emidox's own included model. Other providers are added on request — ask.

Every model runs on credits, 100 to the dollar, at a price per 1,000 tokens published under Billing. The included model costs nothing. Premium includes credits every month; beyond those you add a pack, or turn on auto top-up with a monthly cap so a busy agent can never surprise you. Each run is on your ledger with its agent, model, tokens and credits, and the month can be exported as a CSV.

Which model, when: a cheap, fast one (Gemini Flash, DeepSeek flash, Claude Haiku) for reading, sorting and tagging at volume; a strong one (GPT-5.6, Claude Sonnet or Opus, DeepSeek pro) for drafting anything a person will read as yours. Because the model is set per agent, a chain can use both — cheap first, strong last.

If a run fails, you see the error where you'd expect it — on the agent. Out of credits, it says so and offers to add some; too much text for the model, or a fault on our side, it says that. Fix the cause and Process again; nothing is silently dropped, and nothing is charged for a run that did not happen.

Every model on the price list can also be called from your own code, through one address that speaks OpenAI's API. Runs are paid from the same credits as your agents, at the same prices, and each one shows under Billing → Activity with the key's name, the model, the tokens and the credits.

1. Make a key. Open the profile menu → Billing → API keys → Create key. Name it after what will use it, and give it a monthly limit in credits if you want one. The key is shown once: copy it then. A lost key can't be shown again — revoke it and make another.
2. Point your code at Emidox. The base URL is https://api.emidox.com/v1. Any OpenAI library works: give it that base URL, and your Emidox key as the API key.
3. Pick a model. emidox-120b is the included model and costs nothing. Every model's id and price are listed at https://api.emidox.com/v1/models, which needs no key, and under Billing → Model prices.

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.emidox.com/v1",
  apiKey: process.env.EMIDOX_API_KEY,
});

// One answer, all at once.
const answer = await client.chat.completions.create({
  model: "emidox-120b",
  messages: [{ role: "user", content: "Sum up this week in two lines." }],
});
console.log(answer.choices[0].message.content);
console.log(answer.usage); // tokens, and cost_credits: what the run cost

// Streamed: the words arrive as they are written.
const stream = await client.chat.completions.create({
  model: "emidox-120b",
  messages: [{ role: "user", content: "Draft a short post about our launch." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Python

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.emidox.com/v1",
    api_key=os.environ["EMIDOX_API_KEY"],
)

# One answer, all at once.
answer = client.chat.completions.create(
    model="emidox-120b",
    messages=[{"role": "user", "content": "Sum up this week in two lines."}],
)
print(answer.choices[0].message.content)
print(answer.usage)  # tokens, and cost_credits: what the run cost

# Streamed: the words arrive as they are written.
stream = client.chat.completions.create(
    model="emidox-120b",
    messages=[{"role": "user", "content": "Draft a short post about our launch."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices:  # the last chunk carries only the usage
        print(chunk.choices[0].delta.content or "", end="")

A streamed answer ends with one last chunk that carries the usage — the tokens, and cost_credits — without your having to ask for it. Closing a stream halfway bills only the tokens written so far.

When a request is refused

Errors come back in OpenAI's shape, {"error": {"message", "type", "code"}}, so the libraries raise them as they would OpenAI's own.

Limits

• The included model costs nothing through a key too, so it has limits of its own: 60 requests a minute per key, and a daily allowance of tokens per account. Past either, requests get 429 rate_limited until the minute, or the day, is over.
• Paid models are limited by your balance, and by a key's monthly limit where it has one.
• Keys: up to 20 at a time on an account.

Claude, ChatGPT, Cursor — and any other AI app that speaks MCP, the way these apps reach outside tools — can use your flows. Connect one and ask it, in your own words, to list your flows, run one on what you give it and read the result, or plan and build a new flow. Each flow switched on for AI apps also shows in the app as a tool of its own, named after the flow, so "run the weekly digest on this" finds it.

1. Add Emidox to the app. The address is https://api.emidox.com/mcp. In Claude, add a custom connector in its connector settings and paste the address. In ChatGPT, turn on developer mode in its apps settings, then create a connector with the address. In Cursor, put it in mcp.json (below). There is no key to copy: the app signs you in.
2. Sign in to Emidox. The app opens Emidox's consent screen. It names the app, says in plain words what the app asks to do, and lets you choose which flows it may run — every flow switched on for AI apps, unless you pick fewer. Once you allow it, you are back in the app.
3. Ask. "Which Emidox flows do I have?", "Run Deal handover on these notes", "What did that run say?" The app picks the tool and shows you the answer.

Cursor reads .cursor/mcp.json in a project, or the one in your home folder for every project:

{
  "mcpServers": {
    "emidox": { "url": "https://api.emidox.com/mcp" }
  }
}

What each permission allows

The consent screen lists what the app asks for; a key lists what you tick (below). Nothing else is reached, and deleting a flow or an agent is never offered to an app at all.

Which flows an app sees

Each flow has an Available to AI apps switch. It starts on, except on a flow with an agent that posts or sends outside Emidox — to LinkedIn, X, email, Telegram, Facebook or Instagram. Those start off: a run an AI app starts goes straight to the output, as a Daily run does, so switch one on only when you are happy for an app to send it. An app sees a flow only when the flow is switched on and its sign-in allowed it.

Runs, credits and revoking

• Runs. A run an app starts is in the flow's run history and on the canvas like any other, marked with where it came from: From Claude.
• Credits. It is paid from your wallet at the usual prices — the model tokens of each step — and shows under Billing → Activity as, for example, Claude · Weekly digest. Listing flows and reading runs and memory cost nothing, up to 120 calls a minute for each app or key. Planning a flow is charged as a planner call; building it is free.
• Revoking. Account → Connected AI apps lists every app you have signed in to, with what it may do and when it was last used. Revoke cuts it off at once; it has to ask you again to come back.

From your own product's assistant

A product's own copilot can use the same tools for one of its users, with a key in place of a sign-in.

1. Make a key with permissions. Billing → API keys → Create key, and tick what it may do. A key with no permissions is a model API key only, as every key made before them still is. A key sees every flow switched on for AI apps.
2. Send it to the same address, https://api.emidox.com/mcp, as Authorization: Bearer emx-….
3. Name the user. Add Emidox-Subject: <your user's id> to each call: your own id for them, up to 128 characters. Emidox never needs to know who it is. Runs, memory and the ledger record it, and a flow whose memory is kept per subject gives each subject its own — a run for one never sees another's.

Your own product can start flows. Send Emidox an event each time something happens in it — a deal closed, a ticket opened — and the flows you bound to that event run on it, with the result sent back to your server. Your users never see Emidox.

1. Make an integration. On the Integrations page, make one for your product: its name and, to get results back, a webhook address (https only). Its webhook secret, whsec_…, is shown once: keep it on your server. Lost, it can be rotated on the same page.
2. Make a key that sends events. Billing → API keys → Create key, with the permission Send events that start flows (events:write), made for that integration. A key made for one integration sends only to it; a key made for none names the integration in each event, as integrationId.
3. Bind events to flows. On the integration, add a binding: the event type (exact, or a prefix such as deal.*), a filter if only some of them count, the flow to run, and what its first agent is given — a template such as {{data.account}} closed at {{data.amount}}, or, without one, the event's type with its data as JSON. A binding can also let a burst of events for one subject settle into one run (debounce), cap its runs an hour and its credits a day, and send its result to your webhook or not. One event can match several bindings; each starts its own run.

Sending an event

POST https://api.emidox.com/v1/events
Authorization: Bearer emx-…
Content-Type: application/json

{
  "id": "evt_01J…",
  "type": "deal.closed",
  "subject": "deal_88",
  "occurredAt": "2026-10-31T09:12:00Z",
  "data": { "amount": 42000, "account": "Acme", "owner": "sam@example.com" }
}

• id is your own, and required. The same one sent again within 24 hours is accepted and ignored, so a retry from your side never runs a flow twice.
• type is 1 to 64 lower-case letters, digits, dots and underscores.
• subject is optional: one of your users or records, as Emidox-Subject is. Send it in the body or as that header.
• occurredAt is when it happened, if you know.
• data is up to 256 KB of JSON. It reaches the agents as data, never as instructions: nothing in it can change a flow, switch on a tool or reach another subject.

Events are kept for 30 days, and the integration's page shows each one with what it started.

Results at your webhook

When a run an event started ends, Emidox POSTs to the integration's webhook address. The type is run.succeeded, run.partial, run.failed or run.skipped:

{
  "type": "run.succeeded",
  "runId": "6720…",
  "eventId": "evt_01J…",
  "bindingId": "b_3",
  "subject": "deal_88",
  "flow": { "id": "6717…", "name": "Deal handover" },
  "output": { "text": "…the last step's text, up to 100,000 characters…", "truncated": false },
  "credits": 18,
  "at": "2026-10-31T09:12:41Z"
}

Each call carries two headers: Emidox-Signature: t=<unix time>,v1=<signature> and Emidox-Delivery: <id>.

Checking the signature

Check every call before you trust it. The signature is the hex HMAC-SHA256 of <t>.<body> — the time from the header, a dot, and the body exactly as it arrived — keyed with your whole webhook secret, whsec_ included. Work it out yourself, compare the two in constant time, and refuse anything more than 5 minutes old, so a call copied on the way can't be sent to you again later. Read that route's body raw, before any JSON parsing: in Express, express.raw({ type: "application/json" }); in Flask, request.get_data().

Node

import crypto from "node:crypto";

// rawBody: the body exactly as it arrived (a string or a Buffer), before any
// JSON parsing. secret: your whole webhook secret, whsec_ included.
export function verifyEmidoxSignature(rawBody, header, secret) {
  const parts = {};
  for (const part of String(header ?? "").split(",")) {
    const [key, value] = part.trim().split("=");
    parts[key] = value;
  }
  const t = Number(parts.t);
  if (!Number.isInteger(t) || !/^[0-9a-f]{64}$/.test(parts.v1 ?? "")) return false;
  // Nothing more than 5 minutes old (or ahead of your clock).
  if (Math.abs(Date.now() / 1000 - t) > 5 * 60) return false;
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${parts.t}.${rawBody}`)
    .digest();
  return crypto.timingSafeEqual(expected, Buffer.from(parts.v1, "hex"));
}

Python

import hashlib
import hmac
import time

# raw_body: the body exactly as it arrived (bytes), before any JSON parsing.
# secret: your whole webhook secret, whsec_ included.
def verify_emidox_signature(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(
        part.strip().split("=", 1) for part in (header or "").split(",") if "=" in part
    )
    try:
        t = int(parts["t"])
    except (KeyError, ValueError):
        return False
    # Nothing more than 5 minutes old (or ahead of your clock).
    if abs(time.time() - t) > 5 * 60:
        return False
    message = f"{parts['t']}.".encode() + raw_body
    expected = hmac.new(secret.encode(), message, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts.get("v1", ""))

Repeats

A webhook is delivered at least once. Any answer but a 2xx is tried again, a little later each time, for 24 hours; after that the delivery is marked failed on the Integrations page, where Retry sends it again. So the same delivery can reach you twice: keep the Emidox-Delivery ids you have handled and drop one you have seen. Answer with a 2xx straight away, and do the work after.

The trigger sits on the input and decides when the agent runs — and whether a person is in the loop.

• Manually. Only when you press Process. The result waits in Draft until you submit it. Uses the most recent update. For agents you're still shaping, and for anything you want to read before it goes out.
• Daily. Once a day at a time and time zone you set, on everything that arrived in the last 24 hours. Anything sent through the day waits for that run — on the agent, Process and Draft are greyed out, and pointing at them says when it runs (Runs daily at 9:00 AM) — and the run's result goes straight to the output.
• On update. The moment something arrives, it is handled and sent. For sources where each item deserves its own answer.
• Off. The agent keeps its settings and does nothing.

One agent does one job. When the work has more than one step, chain agents into a flow: the first writes to an Emidox storage source, the next reads from it. The canvas draws the chain, and the Flow switch on an agent shows it in its place in the chain.

You don't have to build the chain by hand. Press New agent and describe every step — "Sum up new mentions, then post the summary to LinkedIn" — and it builds the agents and connects them on the canvas, as drafts you can open and change.

Router mode is for the case where the next step depends on the content. Turn it on, connect several agents after the router, and the router agent reads each result and decides which of them gets it — from its prompt, so you can tell it exactly how to choose. Ebiblo uses one router to send material to the right subject agent; the same mechanism carries any branching logic you can describe.

Two things can be paused. Pause the AI model on an agent and data passes from its input to its output untouched — useful for moving something through a flow without processing it. Pause the agent and it stops triggering altogether until you unpause it.

The Output column takes a source that publishes. Pick it from the left menu the same way as an input.

• LinkedIn, X.com, Telegram. The result is posted to the connected account, page or channel. The prompt decides format and length; the source decides where.
• Email. The result is sent from the connected address — a reply, a report, a digest to whoever should have it.
• Ebiblo quiz page. The result arrives on a quiz page as a question set, where a person approves it before learners see it. Give the page a name that says what it's for — "Reading", "Report to parent", whatever helps you find it.
• Emidox. Storage — the next agent in a flow reads from it.

On Starter, emails an agent sends carry a one-line Powered by Emidox credit at the bottom. Premium removes it. Posts to LinkedIn, X and Telegram never carry it on any plan.

Ebiblo is a separate product — a knowledge-check app where AI drafts questions from a tutor's material, a person approves them, and learners answer on any device. It has its own customers and its own pricing. It contains no AI of its own. Every question it shows a learner was written by an Emidox agent.

The flow: a tutor opens an Ebiblo input page from inside Ebiblo and sends material through it — that page is an Emidox input source. A router agent reads the submission and hands it to the right subject agent. That agent checks, rewrites and completes the questions, and its output is an Ebiblo quiz page, where the set waits for a person's approval. It runs on update. Both pages deep-link into Ebiblo, so the tutor never leaves it unless they want to.

What that means if you use both: one sign-in for both apps; the agents behind your quiz pages are on your Emidox canvas to open and edit; and every paid Ebiblo plan includes Emidox Premium, so there is nothing extra to buy. Ebiblo sign-ups also start with a sample agent already made, on the included model, and the credits are one wallet across both apps — so an Ebiblo user may never open Emidox at all.

Ebiblo is also the reason to trust the rest of this guide. It is not a demo we built for a page: it is a business running on the same Input → Prompt → Output shape you are about to make.

1. Put something real in the input. Yesterday's scrape, a real mention, a test submission on an Ebiblo input page.
2. Press Process. The agent runs once and the result appears as a draft. Nothing is sent.
3. Read the draft as the recipient. Not "is it correct" — "would I be glad to receive this". You can fix it by hand right there and submit it; but if you're fixing the same thing twice, fix the prompt instead.
4. Run again. Save when two drafts in a row go out without a hand edit.
5. Set the trigger and Save. Then leave it alone for a day and read what it sent.

Editing the draft is the human check. Use it freely on manual runs — that's what it's for. Just remember that Daily and On-update runs skip it.

The profile menu (the green dot, bottom left) holds four things: Profile, Settings, Billing and Log out.

Plans. Starter is free and stays free: up to 20 agents, a small number of chained agents, a subset of integrations, basic support, and a one-line credit on emails. Premium is the paid plan — unlimited agents and chains, every integration, priority support, and no credit line. You see a Starter limit the moment you reach it, in the app; upgrading turns it on. Cancel Premium and you drop back to Starter — agents stay, the ones over the limit stop running. Ebiblo's paid plans include Premium. See pricing.

Credits. Billing shows your balance, what this month cost by agent, model or day, and the price of every model. Credits you buy don't expire while your account is open; the ones Premium includes come back each month.

Devices. Emidox is a web app today. A mobile app is planned.

Your data. The material that passes through an agent is kept so a run can be repeated and inspected, and goes only to the provider of the model you chose and the destination you chose. Deleting an agent deletes its runs; deleting your account deletes everything.