Robonote documentation

Connect Robonote to your phone system, CRM and data tools. Send us your calls, and get the analysis back where your team works.

Quickstart

Get from zero to your first analyzed call.

1. Get accessAsk your Robonote contact to set up your company and give you access to the Client API.
2. Open the API referenceGo to client-api.robonote.io. There you can see every endpoint, authorize with your credentials and try requests in the browser.
3. Send a callSend a recording together with its details: the agent, the team, the customer and the date. Add your own custom fields if you need them. They come back with every result.
4. Get the resultsAdd a webhook URL in Integrations in the Robonote platform, or ask for S3 exports. Results arrive as soon as each analysis step is done.

How it works

1. Your systems send interactions to Robonote: calls, meetings, chats and emails, with their details.
2. Robonote transcribes, translates and analyzes them: summaries, scores, events, flows and signals.
3. The results go back to you by webhook (JSON) or as hourly CSV files in Amazon S3.

Each interaction keeps one ID from start to end, so you can always match results to the call in your own system.

Data in: Client API

Use the Client API to send calls, chats and emails to Robonote. The live reference, with every field and a "Try it out" button, is at client-api.robonote.io.

Authentication

Every request carries your company API token. You find it on the Integrations page in Robonote.

Authorization: Bearer <company-api-token>

How imports work

Imports are queued and processed in the background. A 200 response with "result": "success" means the request was queued, not that the call was stored.

• Keep the request_id from the response. Support will ask for it.
• Confirm the upload with the status endpoints.

A queued request can still be rejected later, when:

• The API token does not belong to a company.
• Call, chat or email import is not turned on for your company.
• The same recording is already stored under another call_id, or a chat or email with the same messages is already stored under another id. It is stored under your id as a duplicate and is not analyzed. The single-call status endpoint answers status: duplicate with the original id.
• The recording is shorter than 3 seconds, is not a valid audio file, or cannot be downloaded.

Rules for requests

v1 and v2

Both versions accept the same payloads. They differ in one step.

In both versions the recording is downloaded in the background after the request is accepted.

Endpoints

Use the server address shown in the API reference. In the examples below it is $ROBONOTE_API.

Import a call

POST /api/v2/calls/api-import

Send the call with your own call_id and a link to the recording. The example shows the main fields. See the API reference for all fields.

export ROBONOTE_API="https://..."   # server from the API reference
export ROBONOTE_TOKEN="<company-api-token>"

curl -X POST "$ROBONOTE_API/api/v2/calls/api-import" \
  -H "Authorization: Bearer $ROBONOTE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "call_id": "crm-call-10482",
    "recording_file": "https://files.example.com/calls/10482.mp3",
    "time": "2026-11-05 14:32:10",
    "agent_id": "agent-17",
    "client_id": "client-5521"
  }'

import os, requests

API = os.environ["ROBONOTE_API"]        # server from the API reference
TOKEN = os.environ["ROBONOTE_TOKEN"]

r = requests.post(
    f"{API}/api/v2/calls/api-import",
    headers={"Authorization": f"Bearer {TOKEN}"},
    json={
        "call_id": "crm-call-10482",                  # your own id, always a string
        "recording_file": "https://files.example.com/calls/10482.mp3",
        "time": "2026-11-05 14:32:10",                # UTC
        "agent_id": "agent-17",
        "client_id": "client-5521",
    },
    timeout=30,
)
print(r.status_code, r.json())   # keep request_id for support

const API = process.env.ROBONOTE_API;     // server from the API reference
const TOKEN = process.env.ROBONOTE_TOKEN;

const res = await fetch(`${API}/api/v2/calls/api-import`, {
  method: "POST",
  headers: { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    call_id: "crm-call-10482",                 // your own id, always a string
    recording_file: "https://files.example.com/calls/10482.mp3",
    time: "2026-11-05 14:32:10",               // UTC
    agent_id: "agent-17",
    client_id: "client-5521",
  }),
});
console.log(res.status, await res.json());  // keep request_id for support

Response

{
  "result": "success",
  "request_id": "..."
}

Import a chat or email

POST /api/v2/chat-calls/api-import   POST /api/v2/email-calls/api-import

Same request as a call import: same header, same 200 answer. Only the path, your own id field and the messages array change. There is no recording to fetch, so the text you send is what gets analyzed. Email import is only in v2.

curl -X POST "$ROBONOTE_API/api/v2/chat-calls/api-import" \
  -H "Authorization: Bearer $ROBONOTE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "chat_call_id": "crm-chat-10482",
    "chat_call_status": "ANSWERED",
    "time": "2026-11-05 14:32:10",
    "agent_id": "agent-17",
    "agent_name": "Dana Levi",
    "team_id": "team-4",
    "team_name": "Service Desk",
    "client_id": "client-5521",
    "client_name": "Eva Richter",
    "custom_data": { "case_reference": "CASE-4107" },
    "chat_call": [
      { "is_agent": true,  "is_client": false, "time": "2026-11-05 14:32:10",
        "text": "Good morning, how can I help?" },
      { "is_agent": false, "is_client": true,  "time": "2026-11-05 14:32:40",
        "text": "The access point was replaced yesterday and both rooms work again." },
      { "is_agent": true,  "is_client": false, "time": "2026-11-05 14:33:05",
        "text": "Thank you for confirming. May I close the technical issue?" },
      { "is_agent": false, "is_client": true,  "time": "2026-11-05 14:33:30",
        "text": "Yes, but please keep my complaint about the first response open." }
    ]
  }'

curl -X POST "$ROBONOTE_API/api/v2/email-calls/api-import" \
  -H "Authorization: Bearer $ROBONOTE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "email_call_id": "crm-email-10482",
    "email_call_status": "email",
    "time": "2026-11-05 09:15:00",
    "agent_id": "agent-17",
    "agent_name": "Dana Levi",
    "team_id": "team-4",
    "client_id": "client-5521",
    "client_name": "Eva Richter",
    "email_call": [
      { "is_agent": true,  "is_client": false, "time": "2026-11-05 09:15:00",
        "text": "<html><body><p>Hello,</p><p>Here is the quote you asked for.</p></body></html>" },
      { "is_agent": false, "is_client": true,  "time": "2026-11-05 11:40:00",
        "text": "<html><body><p>Thank you, I will review it with our owner this week.</p></body></html>" }
    ]
  }'

Every message carries the same four fields:

Check the status

GET /api/v2/call/{callId} for one call, or GET /api/v2/calls/uploaded for several.

curl "$ROBONOTE_API/api/v2/call/crm-call-10482" \
  -H "Authorization: Bearer $ROBONOTE_TOKEN"

r = requests.get(
    f"{API}/api/v2/call/crm-call-10482",
    headers={"Authorization": f"Bearer {TOKEN}"},
    timeout=30,
)
print(r.json())

If the same recording was already stored under another id, the answer is status: duplicate with the original id. See the API reference for every status.

Data out: choose a method

Get your results through webhooks, hourly CSV files in Amazon S3, or both.

Both need company-level setup. Results depend on which analysis runs for your company.

Webhooks

Each webhook is an HTTP POST with JSON for one interaction. Analysis steps can finish at different times, so you may get several updates for the same interaction.

Full webhook reference: webhooks.robonote.io

Webhook types

Every request includes

• Company and interaction IDs
• The analysis results
• Interaction, agent, team and customer details
• Your custom fields, when you sent them

Set up your endpoint

1. In the Robonote platform, open Integrations.
2. Choose a webhook type and enter your URL.
3. Add authentication headers if your endpoint needs them.
4. Turn it on. One URL per type. Several types can share a URL.

Example receiver

// A minimal webhook receiver (Node.js + Express)
import express from "express";

const app = express();
app.use(express.json({ limit: "5mb" }));

app.post("/robonote/webhook", (req, res) => {
  // 1. Answer fast: Robonote waits up to 3 seconds.
  res.sendStatus(200);

  // 2. Do the real work after you answered.
  setImmediate(() => {
    const result = req.body;          // one interaction, one analysis step
    saveOrUpdate(result);             // same interaction ID = update, not a new record
  });
});

app.listen(3000);

# A minimal webhook receiver (Python + Flask)
from threading import Thread
from flask import Flask, request

app = Flask(__name__)

@app.post("/robonote/webhook")
def robonote_webhook():
    result = request.get_json(force=True)   # one interaction, one analysis step
    # Answer fast (within 3 seconds), then do the real work in the background.
    Thread(target=save_or_update, args=(result,)).start()
    return "", 200

if __name__ == "__main__":
    app.run(port=3000)

# Test your endpoint before you add it in Robonote
curl -X POST https://your-domain.com/robonote/webhook \
  -H "Content-Type: application/json" \
  -d '{"test": true}' \
  -w "\nHTTP %{http_code} in %{time_total}s\n"

Delivery rules

Amazon S3 exports

Robonote stores CSV exports in its own AWS account and gives your team access. Ask your Robonote contact for permissions and the bucket details.

What each export includes

Every file includes the interaction details and your custom fields. No audio. Empty data types are left out.

How the hourly batch works

• Hourly. Batches start at minute 48 of every hour. Files appear after processing and upload.
• By analysis time. Selection uses the latest analysis time, so an older call that was analyzed again today can be in today’s batch.
• Window. The first export covers the past 24 hours. Each next one starts where the last one ended, up to 7 days.
• Download Errors. Selected by the original call time, so new failures on old calls can fall outside the window.

Files and updates

• Files are grouped by data type and time period. Robonote gives you the locations.
• A rerun creates new files. Old batches stay. Retrying a batch can replace its files.
• Files hold the latest results. Changing only the call details does not trigger an export.
• Files can appear at different times. No webhook announces a finished batch.

Reruns and updates

Custom integrations

Using a phone system, dialer or CRM that is not covered here? Our team builds the integration for you, tests it, and stays with you after it goes live.

Book a Demo

Support

Questions about the API or your setup? Write to [email protected].