API

DiscMeet exposes a small read-only HTTP API under /v1. You call it from your own scripts, backends, or ETL jobs using a server-specific API key (not your Discord login). Responses are JSON and include meeting metadata, notes, transcript text, and related fields for each listed recording.

BASE URL

https://api.discmeet.com/v1

Who can use it

• The Discord server must have the DiscMeet bot installed and enabled.
• Pro+ on the guild owner’s account is required to create or rotate an API key.
• Anyone who can open Integrations  for that server (Administrator, Manage Server, or server owner) can generate or revoke the key from the dashboard.

Creating and storing an API key

Keys are created in the browser—there is no “sign up for API key” form outside the dashboard.

1. Sign in at discmeet.com/dashboard .
2. Select the Discord server.
3. Open Integrations (or the API section within Integrations, depending on the UI layout).
4. Use generate / rotate to create a token. Copy it once; the full secret is not shown again (you may see only a last-four hint afterward).
5. Store it in a secret manager or environment variable on the system that calls the API—never commit it to git or send it in client-side browser code.

Sending the API key (authentication)

Authorization: Bearer <token>

Endpoints (quick links)

All endpoints use the same auth header, plan gating, and rate limits. List responses share the same shape (different top-level key: meetings / sessions / campaigns); single-resource endpoints wrap their object under meeting, session, or campaign.

Pagination

List endpoints (/v1/meetings, /v1/sessions) accept these query params:

Each page contains up to limit items (default 50). The response includes a meta object:

When meta.next is true, request the next page with ?page=<current + 1> (and the same since / limit if you used them).

What appears in lists (eligibility)

Only ended meetings or ended RPG sessions are listed, and only if:

• A transcription exists, and
• Notes are non-empty (same practical rule as the dashboard transcript list: empty or cleared notes are skipped).

Only sessions whose started_at is within the last 30 days are included (aligned with the dashboard transcript window).

Rate limits

Two independent limits apply (both are 100 requests per 60 seconds):

1. Per client IP — Enforced before your token is validated. Applies to any path under /v1.
2. Per guild — After the token is resolved to a server.

On 429 Too Many Requests, the response may include:

• Header Retry-After: suggested wait time in seconds.
• Headers X-RateLimit-Limit and X-RateLimit-Window (guild limit path).

JSON body shape for rate limits:

{
  "error": "rate_limited",
  "message": "IP rate limit exceeded (100 requests per 60 seconds).",
  "scope": "ip"
}

scope is either "ip" or "guild".

Error responses

Errors use a small JSON envelope suitable for both humans and automation:

Common HTTP status codes:

Examples:

{ "error": "unauthorized", "message": "Invalid or missing Bearer token." }

{
  "error": "rate_limited",
  "message": "Guild rate limit exceeded (100 requests per 60 seconds).",
  "scope": "guild"
}

Unknown paths under /v1 may still return an HTML 404 from the framework instead of JSON until handled at the edge.

Response object fields (list items)

Each object in meetings or sessions includes:

These JSON responses are not signed; treat HTTPS and your token handling as the trust boundary.

Example requests (by language)

Replace YOUR_TOKEN and adjust the path (meetings or sessions) as needed.

curl -sS \
  -H "Authorization: Bearer YOUR_TOKEN" \
  "https://api.discmeet.com/v1/meetings?page=1"

const token = process.env.DISCMEET_API_TOKEN;
const url = new URL('https://api.discmeet.com/v1/meetings');
url.searchParams.set('page', '1');
 
const res = await fetch(url, {
  headers: { Authorization: `Bearer ${token}` },
});
 
if (!res.ok) {
  const err = await res.json().catch(() => ({}));
  throw new Error(err.message || res.statusText);
}
 
const data = await res.json();
console.log(data.meetings?.length, data.meta);

import os
import urllib.request
 
token = os.environ["DISCMEET_API_TOKEN"]
req = urllib.request.Request(
    "https://api.discmeet.com/v1/meetings?page=1",
    headers={"Authorization": f"Bearer {token}"},
)
with urllib.request.urlopen(req) as resp:
    import json
    data = json.load(resp)
print(len(data.get("meetings", [])), data.get("meta"))

package main
 
import (
	"fmt"
	"io"
	"net/http"
	"os"
)
 
func main() {
	token := os.Getenv("DISCMEET_API_TOKEN")
	req, _ := http.NewRequest("GET", "https://api.discmeet.com/v1/meetings?page=1", nil)
	req.Header.Set("Authorization", "Bearer "+token)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	fmt.Println(res.StatusCode, string(body))
}

require 'net/http'
require 'json'
 
token = ENV.fetch('DISCMEET_API_TOKEN')
uri = URI('https://api.discmeet.com/v1/meetings?page=1')
req = Net::HTTP::Get.new(uri)
req['Authorization'] = "Bearer #{token}"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
data = JSON.parse(res.body)
puts data['meetings']&.size, data['meta']

LLM / integration notes

• Intent: Fetch recent transcript rows for one Discord server using a static Bearer token.
• Idempotency: GET only; safe to retry (respect 429 + Retry-After).
• Correlation: Use meeting_id as the stable id for a recording when syncing or deduplicating.
• Completeness: Lists are paginated and filtered (30-day window, non-empty notes). Do not assume a single page is the full history.
• Secrets: Never log the full Authorization header.

Next

• GET /v1/meetings — list with since / limit / page
• GET /v1/meetings/:id — single meeting by UUID
• GET /v1/sessions
• Webhooks — HTTPS callbacks when transcripts (and optionally audio) are ready
• MCP — connect Claude Code, Claude Desktop, Cursor, or Codex directly to your meeting notes