DEVELOPER HUB

One API and 16 Calljotting Services

One API, 16 AI-powered services for call transcription, jot extraction, streaming, search, and analytics. Every service is powered by the same core algorithm pipeline. See the technical report for the full research methodology.

🤖 Algorithm Pipeline

All 16 services derive from the same core pipeline. The full research methodology, architecture details, and performance benchmarks are documented in the CallJots Algorithm technical report (ISBN 978-1-7646531-2-1).

Audio (8kHz WAV/MP3) or Text
    |
    v
[Stage 1] Whisper ASR (or direct text input)
    |   Transcribes speech to text with word-level timestamps
    v
[Stage 2] sentence-transformers (all-MiniLM-L6-v2)
    |   Converts each utterance into 384-dim embedding
    v
[Stage 3] DNN-HMM Classifier
    |   Text: 384-dim embedding
    |   Audio: RBM-DBN features from Fbank(80)
    |   Fusion: Concat -> Linear -> ReLU -> Softmax
    |   HMM: Viterbi temporal smoothing across utterance sequence
    v
[Stage 4] Entity Extraction + Post-processing
    |   Phone numbers, dates, times, money, emails, URLs, people, organisations
    v
Jots: { topic, question, commitment, action_item, decision }

Jot Classes

124,794

Labelled Utterances

📖

Technical Report

All 16 Services

LIVE

LIVE

LIVE

LIVE

LIVE

DEV

DEV

DEV

DEV

DEV

LIVE

LIVE

LIVE

SOON

SOON

🔑 Authentication

All API requests require a Bearer token in the Authorization header. Get your API key by registering.

# All requests:
Authorization: Bearer cj_live_abc123def456...

# Register for an API key:
POST https://api.calljots.com/v1/auth/register
Content-Type: application/json

{
  "email": "dev@example.com",
  "password": "your-secure-password",
  "organization": "Acme Corp"
}

# Response:
{
  "success": true,
  "data": {
    "api_key": "cj_live_abc123...",
    "user_id": "uuid",
    "rate_limit": 120,
    "rate_limit_window": "1m"
  }
}

Rate Limits

Limit	Value
Burst	120 req/min
Sustained	5,000 req/day
Upload Chunk	12 req/min
Text Extract	60 req/min
WebSocket Chunks	5 chunks/sec (burst 15)

LIVE Service 1 — Audio Transcription & Jot Extraction

Upload an audio file (WAV/FLAC/MP3/OGG/M4A, max 500MB / 4 hours). The pipeline transcribes with Whisper, classifies each utterance into jots, and extracts entities. Returns a job_id for async polling.

POST/api/v1/jobs/transcribe

Request (multipart/form-data)

Field	Type	Required	Description
file	file	Yes	WAV, FLAC, MP3, OGG, M4A (max 500MB/4hr)
threshold	float	No	Worthiness threshold (default 0.3, range 0.0-1.0)
use_hmm	bool	No	Apply HMM Viterbi smoothing (default true)
checkpoint	string	No	Model checkpoint (default: sent_emb_only_best.pt)
webhook_url	string	No	POST results to this URL on completion
call_id	string	No	Optional call identifier for grouping

Code Examples

# curl
curl -X POST https://api.calljots.com/v1/jobs/transcribe \
  -H "Authorization: Bearer cj_live_abc123" \
  -F "file=@call-recording.wav" \
  -F "threshold=0.3" \
  -F "use_hmm=true"

# Python
import requests

url = "https://api.calljots.com/v1/jobs/transcribe"
headers = {"Authorization": "Bearer cj_live_abc123"}
files = {"file": open("call-recording.wav", "rb")}
data = {"threshold": 0.3, "use_hmm": "true"}

resp = requests.post(url, headers=headers, files=files, data=data)
job = resp.json()
print(f"Job ID: {job['data']['job_id']}")

# JavaScript (Node.js)
const FormData = require('form-data');
const fs = require('fs');
const axios = require('axios');

const form = new FormData();
form.append('file', fs.createReadStream('call-recording.wav'));
form.append('threshold', '0.3');
form.append('use_hmm', 'true');

const resp = await axios.post(
  'https://api.calljots.com/v1/jobs/transcribe',
  form,
  { headers: { ...form.getHeaders(), Authorization: 'Bearer cj_live_abc123' } }
);
console.log(resp.data.data.job_id);

# PHP (cURL)
$ch = curl_init('https://api.calljots.com/v1/jobs/transcribe');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer cj_live_abc123',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, [
    'file' => new CURLFile('/path/to/call-recording.wav'),
    'threshold' => '0.3',
    'use_hmm' => 'true',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$resp = json_decode(curl_exec($ch), true);
echo "Job ID: " . $resp['data']['job_id'];

Response (202 Accepted)

{
  "success": true,
  "data": {
    "job_id": "uuid",
    "status": "queued",
    "estimated_seconds": 45,
    "status_url": "/api/v1/jobs/{job_id}"
  }
}

Polling for Results

# curl
curl -H "Authorization: Bearer cj_live_abc123" \
  https://api.calljots.com/v1/jobs/{job_id}?include_transcript=true

Billing

$0.02

Per audio minute

60 min

Free tier monthly

LIVE Service 2 — Text-Only Jot Extraction

Provide text directly for jot classification. No audio needed. The text is split into utterances, embedded via sentence-transformers, and classified through the dual-head model. Entities are extracted automatically.

POST/api/v1/jots/extract

Request

{
  "text": "I will send you the report by Friday. Please review it. We decided to go with option B.",
  "threshold": 0.3,
  "use_hmm": true
}

Code Examples

# curl
curl -X POST https://api.calljots.com/v1/jots/extract \
  -H "Authorization: Bearer cj_live_abc123" \
  -H "Content-Type: application/json" \
  -d '{"text":"I will send you the report by Friday.","threshold":0.3,"use_hmm":true}'

# Python
import requests

resp = requests.post(
    "https://api.calljots.com/v1/jots/extract",
    headers={
        "Authorization": "Bearer cj_live_abc123",
        "Content-Type": "application/json"
    },
    json={
        "text": "I will send you the report by Friday.",
        "threshold": 0.3,
        "use_hmm": True
    }
)
data = resp.json()["data"]
for jot in data["jots"]:
    print(f"[{jot['jot_type']}] {jot['text']} (conf={jot['confidence']})")

Response

{
  "success": true,
  "data": {
    "jots": [
      {
        "utterance_index": 0,
        "text": "I will send you the report by Friday.",
        "jot_type": "commitment",
        "confidence": 0.87,
        "class_probabilities": {
          "topic": 0.05, "question": 0.03,
          "commitment": 0.87, "action_item": 0.03, "decision": 0.02
        },
        "jot_probability": 0.92,
        "is_jot_worthy": true,
        "entities": {
          "dates": [{"value": "Friday", "type": "weekday"}]
        }
      }
    ],
    "utterance_count": 1,
    "jots_extracted": 1,
    "entities": { ... },
    "input_spec": { ... },
    "output_spec": { ... }
  }
}

Billing

$0.50

Per 1,000 utterances

5,000

Free utterances monthly

LIVE Service 3 — Streaming Jot Extraction (WebSocket)

Real-time WebSocket endpoint for streaming audio. Send audio chunks as they arrive (PCM 16-bit, 16kHz mono, base64-encoded, 8MB chunks). Receive partial transcripts, utterance-complete jots, and a final summary.

WSS/api/v1/stream/jots?token=<api_key>

Client Messages

// Audio data chunk
{ "type": "audio_chunk", "data": "<base64 PCM 16-bit 16kHz mono>", "sequence": 1 }

// Configuration mid-stream
{ "type": "config", "threshold": 0.3, "use_hmm": true }

// Keepalive
{ "type": "ping" }

// End stream
{ "type": "close", "reason": "call_ended" }

Server Messages

// Connection acknowledged
{ "type": "connected", "session_id": "uuid", "config": { "chunk_size_bytes": 8388608 } }

// Partial transcript (low latency)
{ "type": "partial", "transcript": "So let's discuss...", "jots": [], "sequence": 1 }

// Complete utterance with jots
{ "type": "utterance_complete",
  "utterance_index": 0,
  "transcript": "So let's discuss the budget",
  "jots": [{ "jot_type": "topic", "confidence": 0.91, ... }],
  "duration_seconds": 3.0 }

// Stream complete
{ "type": "final", "total_jots": 12, "total_utterances": 43, "duration_seconds": 180.5 }

Code Examples

# JavaScript (Browser)
const ws = new WebSocket(
  "wss://api.calljots.com/v1/stream/jots?token=cj_live_abc123"
);

ws.onopen = () => {
  setInterval(() => {
    ws.send(JSON.stringify({ type: "ping" }));
  }, 30000);
};

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  if (msg.type === "utterance_complete") {
    console.log(`[${msg.jots[0].jot_type}] ${msg.transcript}`);
  }
  if (msg.type === "final") {
    console.log(`Done: ${msg.total_jots} jots in ${msg.duration_seconds}s`);
  }
};

# Python (websockets)
import asyncio, websockets, json, base64

async def stream_audio():
    async with websockets.connect(
        "wss://api.calljots.com/v1/stream/jots?token=cj_live_abc123"
    ) as ws:
        # Send audio chunks
        with open("call.raw", "rb") as f:
            while chunk := f.read(8388608):
                await ws.send(json.dumps({
                    "type": "audio_chunk",
                    "data": base64.b64encode(chunk).decode(),
                    "sequence": 0
                }))
        await ws.send(json.dumps({"type": "close", "reason": "file_end"}))

        # Receive results
        async for msg in ws:
            data = json.loads(msg)
            if data["type"] == "utterance_complete":
                print(data["transcript"], data["jots"])

asyncio.run(stream_audio())

Billing

$0.03

Per streaming minute

30 min

Free streaming minutes

LIVE Service 4 — Batch Processing

Upload up to 50 audio files in a single request. Each file is processed independently through the pipeline. Results are returned as a batch with individual job statuses.

POST/api/v1/jobs/batch

Request (multipart/form-data)

Field	Type	Required	Description
files[]	file[]	Yes	Multiple files (max 50)
threshold	float	No	Default 0.3
use_hmm	bool	No	Default true

# curl
curl -X POST https://api.calljots.com/v1/jobs/batch \
  -H "Authorization: Bearer cj_live_abc123" \
  -F "files=@call1.wav" \
  -F "files=@call2.wav" \
  -F "files=@call3.wav"

Billing

$0.10

Per file in batch

Max files per batch

LIVE Service 5 — Jot Search & Retrieval

Full-text search across all extracted jots. Filter by jot type, confidence, entity presence (phone, email, person, location, organisation), date range, and more. Entity-enriched search enables cross-referencing — find all jots mentioning a specific person or phone number.

GET/api/v1/jots/search?q=<query>&jot_type=<type>&phone=<number>

Query Parameters

Param	Type	Description
q	string	Full-text search
jot_type	string	topic, question, commitment, action_item, decision
min_confidence	float	Minimum confidence (0.0-1.0)
phone	string	Phone number substring
email	string	Email address substring
person	string	Person name substring
location	string	Location name substring
organization	string	Organisation name substring
date_from	string	YYYY-MM-DD
date_to	string	YYYY-MM-DD
limit	int	Max results (default 20, max 500)

# Find all jots mentioning a person and location
curl -H "Authorization: Bearer cj_live_abc123" \
  "https://api.calljots.com/v1/jots/search?person=Smith&location=Sydney&limit=25"

# Find all action items from last week
curl -H "Authorization: Bearer cj_live_abc123" \
  "https://api.calljots.com/v1/jots/search?jot_type=action_item&date_from=2026-09-01"

Billing

$0.10

Per 1,000 search requests

100

Free searches monthly

LIVE Service 6 — Jot CRUD Operations

Create, read, update, and delete jots manually. Useful for correcting algorithm predictions, adding human-verified jots, or integrating with external systems.

Method	Endpoint	Description
POST	/api/v1/jots	Create a manual jot
GET	/api/v1/jots/{id}	Get jot detail (?deep=true for logits)
PATCH	/api/v1/jots/{id}	Update jot type, confirm/reject
DELETE	/api/v1/jots/{id}	Delete a jot

Head Inspection Endpoints

// Full inference transparency — raw logits, HMM matrix, input embedding
GET /api/v1/jots/{id}/type-head
GET /api/v1/jots/{id}/type-head/explain
GET /api/v1/jots/{id}/worthiness-head
GET /api/v1/jots/{id}/worthiness-head/explain

Code Examples

# Python — Update a jot
import requests

resp = requests.patch(
    "https://api.calljots.com/v1/jots/uuid",
    headers={"Authorization": "Bearer cj_live_abc123"},
    json={"jot_type": "action_item", "confirmed": True}
)
print(resp.json())

Billing

Free

CRUD operations

Unlimited

No rate limit for CRUD

DEV Service 7 — Call Lifecycle Events

Extract higher-order call events: topic shifts, decision points, question clusters, and call phases. Post-processes the raw jot stream to identify conversation structure.

GET/api/v1/calls/{id}/events

// Returns (planned):
{
  "events": [
    { "type": "topic_shift", "at": 45.2, "from": "budget", "to": "timeline" },
    { "type": "decision_point", "at": 120.8, "summary": "Selected vendor B" },
    { "type": "question_cluster", "at": 200.0, "count": 5 }
  ]
}

TBD

Billing in development

DEV Service 8 — Speaker-Annotated Transcript

Retrieve the full transcript with speaker labels, word-level timestamps, and embedded jots. Supports multiple output formats including JSON, plain text, SRT, and VTT for subtitles.

GET/api/v1/calls/{id}/transcript?format=json|text|srt|vtt

// Returns (planned):
{
  "utterances": [
    {
      "speaker": "speaker_1",
      "text": "Let's schedule a meeting for next Tuesday.",
      "start": 0.0, "end": 3.2,
      "jots": [{ "jot_type": "action_item", "confidence": 0.87 }]
    }
  ],
  "speaker_stats": { "speaker_1": { "words": 1240, "percent": 58 } }
}

TBD

Billing in development

DEV Service 9 — Call Summarization

Generate natural-language summaries of calls using the extracted jots and transcript. Choose from different summary lengths and focus areas (action items, decisions, topics).

POST/api/v1/summarize

{
  "transcript": ["utterance 1", "utterance 2"],
  "jots": [...],
  "length": "brief",
  "focus": "action_items"
}

TBD

Billing in development

DEV Service 10 — Call Log Management

Register, list, and manage call records. Each call can have metadata (title, participants, tags, CRM ID). Calls are automatically linked to their audio jobs and extracted jots.

Method	Endpoint	Description
POST	/api/v1/calls	Register call record
GET	/api/v1/calls	List calls (paginated, filterable)
GET	/api/v1/calls/{id}	Call detail + jot count
PATCH	/api/v1/calls/{id}	Update metadata
DELETE	/api/v1/calls/{id}	Delete call and associated jots

Free

Call metadata storage

DEV Service 11 — Analytics Dashboard

Aggregated analytics across all calls and jots. View trends, type distributions, entity frequency, and usage patterns. Supports time-series breakdowns for monitoring call centre performance.

Endpoint	Description
GET /api/v1/analytics/overview	Summary dashboard
GET /api/v1/analytics/jots	Jot type distribution over time
GET /api/v1/analytics/calls	Call volume, duration, trends
GET /api/v1/analytics/trends	Entity frequency, topic shifts

TBD

Billing in development

LIVE Service 12 — Webhook Callbacks

Register webhooks to receive real-time notifications when jobs complete, jots are extracted, or thresholds are met. Payloads are JSON with HMAC signing for verification.

Method	Endpoint	Description
POST	/api/v1/webhooks	Register webhook
GET	/api/v1/webhooks	List webhooks
DELETE	/api/v1/webhooks/{id}	Delete webhook

Webhook Payload

{
  "event": "job.completed",
  "job_id": "uuid",
  "total_jots": 42,
  "worthy_jots": 31,
  "avg_confidence": 0.79,
  "timestamp": "2026-09-05T14:00:00Z",
  "signature": "sha256=abc123..."
}

# Python — Verify webhook signature
import hmac, hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(), payload.encode(), hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(f"sha256={expected}", signature)

Billing

Free

Webhook delivery

1,000/hr

Max delivery rate

LIVE Service 13 — Model Management

List available model checkpoints with performance metrics, architecture details, and class names. Each checkpoint includes per-class F1 scores from the research evaluation.

GET/api/v1/models

{
  "success": true,
  "data": {
    "models": [
      {
        "checkpoint_id": "sent_emb_only_best.pt",
        "type_f1": 0.7567,
        "weighted_f1": 0.9412,
        "accuracy": 0.9401,
        "architecture": "DualHeadBackbone (text-only)",
        "class_names": ["topic","question","commitment","action_item","decision"]
      }
    ]
  }
}

Billing

Free

Model listing

Unlimited

Inspect any endpoint

LIVE Service 14 — Billing & Usage

View current billing cycle usage, transaction history, and credit balance. Usage is tracked per service type with per-minute, per-utterance, and per-file billing.

Method	Endpoint	Description
GET	/api/v1/billing/usage	Usage stats by service
GET	/api/v1/billing/current	Current cycle summary

Pricing Plans

Free

60 transcribe min/mo
5,000 extracts/mo
30 stream min/mo
50 batch files/mo
100 searches/mo
Community support

POPULAR

Premium

$49

/month

5,000 transcribe min/mo
50,000 extracts/mo
1,000 stream min/mo
500 batch files/mo
10,000 searches/mo
Priority support

Enterprise

Custom

Unlimited transcribe
Unlimited extracts
Unlimited streaming
Unlimited batch
Custom model training
SLA guarantee
Dedicated support

Contact Sales

Per-Service Rates (Free Tier)

Service	Free Tier	Rate
Transcribe	60 min/month	$0.02/min
Text Extract	5,000 utterances	$0.50/1K utterances
Streaming	30 min/month	$0.03/min
Batch	50 files/month	$0.10/file
Search	100 requests/month	$0.10/1K requests
CRUD	Unlimited	Free
Webhooks	Unlimited	Free
Models	Unlimited	Free

SOON Service 15 — Custom Jot Type Training

Train custom jot types on your own labelled data. Upload domain-specific transcripts with labelled jots and the pipeline will train a custom checkpoint. See the CallJots Algorithm technical report for the full research methodology.

POST/api/v1/models/custom-training

{
  "name": "my-custom-jot-types",
  "class_names": ["follow_up", "escalation", "resolution"],
  "training_data": [
    {"text": "I'll call you back tomorrow.", "label": "follow_up"},
    {"text": "Let me transfer you to my manager.", "label": "escalation"}
  ],
  "base_checkpoint": "sent_emb_only_best.pt",
  "epochs": 10
}

TBD

Custom training (GPU time billed)

SOON Service 16 — Model Feedback Loop

Submit feedback on algorithm predictions to improve future models. Each feedback includes the original prediction, the corrected label, and optional notes. See the technical report for details on the training methodology.

Method	Endpoint	Description
POST	/api/v1/feedback	Submit prediction feedback
GET	/api/v1/feedback/stats	Feedback aggregation stats

{
  "jot_id": "uuid",
  "original_type": "commitment",
  "corrected_type": "action_item",
  "correct": false,
  "notes": "This was a task assignment, not a commitment",
  "confidence": 0.42
}

Free

Feedback submissions

🛠 Platform Integration Guide

Integrate CallJots into your call centre, VoIP platform, CRM, or security operations system.

PBX & SIP Integration

CallJots provides a Kamailio SIP server that bridges VoIP carriers to the API. WebRTC is supported via Coturn TURN/STUN. For Matrix federation, CallJots supports multi-site deployment.

# Example: Forward SIP calls to CallJots for analysis
# Kamailio config snippet:
route[CALLJOTS_ANALYSIS] {
    # Send RTP stream to CallJots API
    rtp_proxy_send("udp:api.calljots.com:30000");
    # POST call metadata to API
    curl_post_data("call_id=$callID&from=$fU&to=$rU");
    curl_post("https://api.calljots.com/v1/calls");
}

CCTV / Security Operations

The real-time cursor client lets security personnel monitor live call jots alongside video feeds. Cross-reference by entity (phone number, person name, location) across both audio and video streams.

CRM Integration

Use the webhook service to push completed jots and summaries into your CRM. The HMAC-signed payloads ensure authenticity. Example: automatically create a HubSpot task for every action_item jot.

# Example: Webhook receiver (Python/Flask)
from flask import Flask, request
import hmac, hashlib

app = Flask(__name__)
WEBHOOK_SECRET = "your-secret-key"

@app.route("/webhooks/calljots", methods=["POST"])
def handle_jot():
    payload = request.get_data()
    signature = request.headers.get("X-Signature")

    expected = hmac.new(WEBHOOK_SECRET.encode(), payload, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(f"sha256={expected}", signature):
        return "Invalid signature", 403

    event = request.json
    if event["event"] == "job.completed":
        # Create tasks in CRM for each action_item
        print(f"Job {event['job_id']} completed with {event['total_jots']} jots")
    return "OK", 200

📦 Downloadable Code Packages

Ready-to-run integration packages for every major platform. Each package includes working examples for all 16 services, authentication, error handling, and WebSocket support.

🐈

calljots-client.sh
Bash/curl • 3KB

#!/bin/bash
# CallJots API Client — curl-based
API_KEY="${CALLJOTS_API_KEY:-***}"
BASE="https://api.calljots.com/v1"

# Extract jots from text
extract_jots() {
  curl -s -X POST "$BASE/jots/extract" \
    -H "Authorization: Bearer $API_KEY" \
    -H "Content-Type: application/json" \
    -d "{\"text\":\"$1\",\"threshold\":0.3}"
}

# Upload audio for transcription
transcribe() {
  curl -s -X POST "$BASE/jobs/transcribe" \
    -H "Authorization: Bearer $API_KEY" \
    -F "file=@$1" -F "threshold=0.3"
}

# Check job status
job_status() {
  curl -s -H "Authorization: Bearer $API_KEY" "$BASE/jobs/$1"
}

# Usage examples
extract_jots "I will send you the report by Friday."
transcribe "call.wav"

⬇ Download

🐍

calljots-client.py
Python 3 • 8KB

#!/usr/bin/env python3
"""CallJots API Client — Python SDK"""
import requests, json, time

class CallJotsClient:
    def __init__(self, api_key, base="https://api.calljots.com/v1"):
        self.api_key = api_key
        self.base = base
        self.session = requests.Session()
        self.session.headers.update({"Authorization": f"Bearer {api_key}"})

    def extract(self, text, threshold=0.3, use_hmm=True):
        """Extract jots from text"""
        r = self.session.post(f"{self.base}/jots/extract", json={
            "text": text, "threshold": threshold, "use_hmm": use_hmm
        })
        return r.json()

    def transcribe(self, filepath, threshold=0.3, use_hmm=True):
        """Upload audio for transcription"""
        with open(filepath, "rb") as f:
            r = self.session.post(f"{self.base}/jobs/transcribe",
                files={"file": f}, data={"threshold": threshold})
        return r.json()

    def poll(self, job_id, timeout=300):
        """Poll job until complete"""
        start = time.time()
        while time.time() - start < timeout:
            r = self.session.get(f"{self.base}/jobs/{job_id}?include_transcript=true")
            data = r.json().get("data", {})
            if data.get("status") in ("completed", "failed"):
                return data
            time.sleep(3)
        return {"status": "timeout"}

# Usage
client = CallJotsClient("***")
result = client.extract("I will send the report by Friday.")
for j in result["data"]["jots"]:
    print(f"[{j['jot_type']}] {j['text']}")

⬇ Download

💻

calljots-client.js
Node.js • 6KB

// CallJots API Client — Node.js
const axios = require('axios');

class CallJotsClient {
  constructor(apiKey, base = 'https://api.calljots.com/v1') {
    this.apiKey = apiKey;
    this.base = base;
  }

  async extract(text, threshold = 0.3, useHmm = true) {
    const { data } = await axios.post(`${this.base}/jots/extract`,
      { text, threshold, use_hmm: useHmm },
      { headers: { Authorization: `Bearer ${this.apiKey}` } }
    );
    return data;
  }

  async transcribe(filePath, threshold = 0.3) {
    const FormData = require('form-data');
    const fs = require('fs');
    const form = new FormData();
    form.append('file', fs.createReadStream(filePath));
    form.append('threshold', String(threshold));
    const { data } = await axios.post(`${this.base}/jobs/transcribe`, form, {
      headers: { ...form.getHeaders(), Authorization: `Bearer ${this.apiKey}` }
    });
    return data;
  }

  async poll(jobId, timeout = 300) {
    const start = Date.now();
    while (Date.now() - start < timeout * 1000) {
      const { data } = await axios.get(`${this.base}/jobs/${jobId}?include_transcript=true`,
        { headers: { Authorization: `Bearer ${this.apiKey}` } });
      if (['completed', 'failed'].includes(data.data.status)) return data.data;
      await new Promise(r => setTimeout(r, 3000));
    }
    return { status: 'timeout' };
  }
}

// Usage
const client = new CallJotsClient('***');
client.extract('I will send the report by Friday.').then(console.log);

⬇ Download

💼

calljots-client.php
PHP 8 • 5KB

<?php
// CallJots API Client — PHP
class CallJotsClient {
    private string $apiKey;
    private string $base;

    public function __construct(string $apiKey, string $base = 'https://api.calljots.com/v1') {
        $this->apiKey = $apiKey;
        $this->base = $base;
    }

    public function extract(string $text, float $threshold = 0.3): array {
        $ch = curl_init("$this->base/jots/extract");
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => ["Authorization: Bearer $this->apiKey", 'Content-Type: application/json'],
            CURLOPT_POSTFIELDS => json_encode(['text' => $text, 'threshold' => $threshold]),
            CURLOPT_RETURNTRANSFER => true,
        ]);
        return json_decode(curl_exec($ch), true);
    }

    public function transcribe(string $filepath): array {
        $ch = curl_init("$this->base/jobs/transcribe");
        curl_setopt_array($ch, [
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => ["Authorization: Bearer $this->apiKey"],
            CURLOPT_POSTFIELDS => ['file' => new CURLFile($filepath), 'threshold' => '0.3'],
            CURLOPT_RETURNTRANSFER => true,
        ]);
        return json_decode(curl_exec($ch), true);
    }
}

// Usage
$client = new CallJotsClient('***');
$result = $client->extract('I will send the report by Friday.');
print_r($result['data']['jots']);

⬇ Download

■

CallJots Desktop App
Java Swing Desktop Client • API key activation, extract, transcribe, search, billing, API console • 13KB

⬇ Download for Linux (.deb) ⬇ JAR (any OS) 📄 Source

Native Java Swing desktop application for the CallJots API. Enter your API key to activate, then extract jots, transcribe audio, search by entity, view models, check billing, and use the built-in API console for all 16 services. Dark theme, resizable, cross-platform.

API key activation Jot extraction Audio transcription Entity search API console Cross-platform

All packages include: authentication, error handling, WebSocket streaming support, and HMAC webhook verification.

🚀 Start Building Get API Key

CallJots API v1 — 16 Services — Technical Report