Mesh API

curl "https://api.meshapi.app/v1/events?limit=10&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

X-API-Key: mesh_your_key_here

{
  "data": [],
  "next_cursor": "dGVzdA==",
  "count": 50
}

{ "detail": "Message describing the error" }

{ "status": "ok" }

{
  "event_ids": ["uuid1", "uuid2", "uuid3"],
  "limit_per_event": 500
}

{
  "results": [
    {
      "event_id": "uuid1",
      "segments": [...],
      "next_cursor": null,
      "count": 142
    }
  ],
  "skipped": [
    { "event_id": "uuid3", "reason": "daily_cap_exceeded" }
  ],
  "pulls_used": 2,
  "pulls_remaining_daily": 13,
  "pulls_remaining_monthly": 448
}

curl "https://api.meshapi.app/v1/events?has_transcript=true&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?primary_speaker_id=381194fe-4856-4945-9e49-9809be82e924&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?segment_speaker_id=381194fe-4856-4945-9e49-9809be82e924&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?topic_slug=nato&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?start_date=2026-01-01&end_date=2026-03-31&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?primary_speaker_id=381194fe-...&event_type=press_conference&start_date=2026-01-01&has_transcript=true" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events?updated_after=2026-01-01T00:00:00Z&limit=200" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events/70d5bc85-cd9b-4670-94fb-6d5a7433b1d0/segments?limit=500" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events/70d5bc85-.../segments?segment_speaker_id=381194fe-...&limit=500" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/events/70d5bc85-.../segments?topic_slug=nato&limit=500" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/segments/search?q=tariffs&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/segments/search?q=immigration&segment_speaker_id=381194fe-...&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/segments/search?q=goal&primary_speaker_id=381194fe-...&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/segments/search?q=sanctions&topic_slug=nato&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/segments/search?q=economy&event_type=remarks&start_date=2026-01-01&end_date=2026-06-01&limit=50" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/usage" \
  -H "X-API-Key: mesh_your_key_here"

curl "https://api.meshapi.app/v1/pulls?limit=100" \
  -H "X-API-Key: mesh_your_key_here"

import requests

BASE = "https://api.meshapi.app"
HEADERS = {"X-API-Key": "mesh_your_key_here"}
SPEAKER_ID = "381194fe-4856-4945-9e49-9809be82e924"

# 1. Collect every event ID for this speaker
event_ids = []
cursor = None
while True:
    params = {
        "speaker_id": SPEAKER_ID,
        "has_transcript": "true",
        "limit": 200,
    }
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(f"{BASE}/v1/events", headers=HEADERS, params=params).json()
    event_ids.extend(e["event_id"] for e in resp["data"])
    cursor = resp.get("next_cursor")
    if not cursor:
        break

# 2. Batch-pull transcripts (25 at a time for enterprise, 10 for other plans)
BATCH_SIZE = 25
for i in range(0, len(event_ids), BATCH_SIZE):
    batch = event_ids[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch, "limit_per_event": 500},
    ).json()
    for entry in resp["results"]:
        print(f"{entry['event_id']}: {entry['count']} segments")
    for skip in resp["skipped"]:
        print(f"Skipped {skip['event_id']}: {skip['reason']}")
    if resp["pulls_remaining_daily"] == 0:
        print("Daily cap reached — resume tomorrow")
        break

SPEAKER_A = "381194fe-4856-4945-9e49-9809be82e924"
SPEAKER_B = "f47ac10b-58cc-4372-a567-0e02b2c3d479"

# 1. Fetch events for both speakers in one call using speaker_ids
events = []
cursor = None
while True:
    params = {
        "speaker_ids": f"{SPEAKER_A},{SPEAKER_B}",
        "has_transcript": "true",
        "limit": 200,
    }
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(f"{BASE}/v1/events", headers=HEADERS, params=params).json()
    events.extend(resp["data"])
    cursor = resp.get("next_cursor")
    if not cursor:
        break

# Events come sorted by date (newest first) — already interleaved
event_ids = [e["event_id"] for e in events]

# 2. Batch-pull transcripts
BATCH_SIZE = 25
for i in range(0, len(event_ids), BATCH_SIZE):
    batch = event_ids[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch, "limit_per_event": 500},
    ).json()
    for entry in resp["results"]:
        event = next(e for e in events if e["event_id"] == entry["event_id"])
        speaker = event.get("primary_speaker_name", "Unknown")
        print(f"[{speaker}] {event['canonical_title']}: {entry['count']} segments")
    if resp["pulls_remaining_daily"] == 0:
        break

def get_remaining_pulls():
    usage = requests.get(f"{BASE}/v1/usage", headers=HEADERS).json()
    daily_cap = usage["daily_transcript_pulls_cap"]  # null = unlimited
    monthly_cap = usage["monthly_transcript_pulls_cap"]
    daily_left = (
        daily_cap - usage["daily_transcript_pulls_used"]
        if daily_cap is not None else float("inf")
    )
    monthly_left = (
        monthly_cap - usage["monthly_transcript_pulls_used"]
        if monthly_cap is not None else float("inf")
    )
    return min(daily_left, monthly_left)

budget = get_remaining_pulls()
print(f"Transcript pulls remaining: {budget}")

# Batch-pull only what fits in the remaining budget
BATCH_SIZE = 25
for i in range(0, len(event_ids), BATCH_SIZE):
    batch = event_ids[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch},
    ).json()
    for entry in resp["results"]:
        print(f"{entry['event_id']}: {entry['count']} segments")
    # The batch endpoint gracefully skips events over cap instead of 429-ing
    if resp["skipped"]:
        for skip in resp["skipped"]:
            print(f"Skipped {skip['event_id']}: {skip['reason']}")
        break

# 1. Search for all segments mentioning "tariffs" in press conferences
matched_event_ids = set()
cursor = None
while True:
    params = {
        "q": "tariffs",
        "event_type": "press_conference",
        "start_date": "2026-01-01",
        "limit": 200,
    }
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(
        f"{BASE}/v1/segments/search", headers=HEADERS, params=params
    ).json()
    for seg in resp["data"]:
        matched_event_ids.add(seg["event_id"])
    cursor = resp.get("next_cursor")
    if not cursor:
        break

print(f"Found segments in {len(matched_event_ids)} events")

# 2. Batch-pull the full transcript for each discovered event
event_list = list(matched_event_ids)
BATCH_SIZE = 25
for i in range(0, len(event_list), BATCH_SIZE):
    batch = event_list[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch, "limit_per_event": 500},
    ).json()
    for entry in resp["results"]:
        print(f"{entry['event_id']}: {entry['count']} segments")
    if resp["pulls_remaining_daily"] == 0:
        break

# 1. Check for stale pulls
resp = requests.get(f"{BASE}/v1/pulls?limit=100", headers=HEADERS).json()
stale_ids = [p["event_id"] for p in resp["data"] if p.get("has_updates")]
print(f"{len(stale_ids)} transcripts have newer data")

# 2. Batch re-pull only the updated ones
BATCH_SIZE = 25
for i in range(0, len(stale_ids), BATCH_SIZE):
    batch = stale_ids[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch, "limit_per_event": 500},
    ).json()
    for entry in resp["results"]:
        print(f"Refreshed {entry['event_id']}: {entry['count']} segments")

# 1. Find all press conferences for a speaker
events = []
cursor = None
while True:
    params = {
        "speaker_id": SPEAKER_ID,
        "event_type": "press_conference",
        "has_transcript": "true",
        "limit": 200,
    }
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(f"{BASE}/v1/events", headers=HEADERS, params=params).json()
    events.extend(resp["data"])
    cursor = resp.get("next_cursor")
    if not cursor:
        break

# 2. Pull each transcript and extract Q&A pairs
for event in events:
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": [event["event_id"]], "limit_per_event": 500},
    ).json()
    if not resp["results"]:
        continue
    segments = resp["results"][0]["segments"]

    questions = [s for s in segments if s["is_question"]]
    answers = [s for s in segments if not s["is_question"]]
    print(f"{event['canonical_title']}: {len(questions)} questions, {len(answers)} answer segments")

    # Group questions by question_group_id to see multi-sentence questions
    from collections import defaultdict
    groups = defaultdict(list)
    for q in questions:
        gid = q.get("question_group_id") or q["idx"]
        groups[gid].append(q["sentence_txt"])
    for gid, texts in groups.items():
        print(f"  Q: {' '.join(texts)}")

SPEAKER_A = "381194fe-4856-4945-9e49-9809be82e924"
SPEAKER_B = "f47ac10b-58cc-4372-a567-0e02b2c3d479"
TOPIC = "nato"

def get_topic_segments(topic_slug, speaker_id):
    segments = []
    cursor = None
    while True:
        params = {"speaker_id": speaker_id, "limit": 200}
        if cursor:
            params["cursor"] = cursor
        resp = requests.get(
            f"{BASE}/v1/topics/{topic_slug}/segments",
            headers=HEADERS, params=params,
        ).json()
        segments.extend(resp["data"])
        cursor = resp.get("next_cursor")
        if not cursor:
            break
    return segments

segs_a = get_topic_segments(TOPIC, SPEAKER_A)
segs_b = get_topic_segments(TOPIC, SPEAKER_B)

print(f"Speaker A on {TOPIC}: {len(segs_a)} segments across {len(set(s['event_id'] for s in segs_a))} events")
print(f"Speaker B on {TOPIC}: {len(segs_b)} segments across {len(set(s['event_id'] for s in segs_b))} events")

# Organize by event date for chronological comparison
for seg in sorted(segs_a, key=lambda s: s.get("event_date", "")):
    print(f"  [{seg.get('event_date', '')[:10]}] {seg['sentence_txt'][:120]}")

# 1. Find events with transcripts (market-linked events have kalshi_tickers)
events = []
cursor = None
while True:
    params = {"has_transcript": "true", "limit": 200}
    if cursor:
        params["cursor"] = cursor
    resp = requests.get(f"{BASE}/v1/events", headers=HEADERS, params=params).json()
    events.extend(resp["data"])
    cursor = resp.get("next_cursor")
    if not cursor:
        break

market_events = [e for e in events if e.get("kalshi_tickers")]
print(f"{len(market_events)} events have linked prediction markets")

# 2. For each market-linked event, fetch resolutions and transcript
for event in market_events:
    eid = event["event_id"]

    # Get market resolutions (unmetered)
    resolutions = requests.get(
        f"{BASE}/v1/events/{eid}/resolutions", headers=HEADERS
    ).json()

    # Get transcript topics (unmetered)
    topics = requests.get(
        f"{BASE}/v1/events/{eid}/topics", headers=HEADERS
    ).json()

    print(f"\n{event['canonical_title']}")
    print(f"  Topics: {', '.join(t['slug'] for t in topics)}")
    for r in resolutions.get("resolutions", []):
        print(f"  Market: {r['market_ticker']} → {r['resolution']}")

# 3. Batch-pull the full transcripts for deeper analysis
event_ids = [e["event_id"] for e in market_events]
BATCH_SIZE = 25
for i in range(0, len(event_ids), BATCH_SIZE):
    batch = event_ids[i : i + BATCH_SIZE]
    resp = requests.post(
        f"{BASE}/v1/events/batch-segments",
        headers=HEADERS,
        json={"event_ids": batch, "limit_per_event": 500},
    ).json()
    for entry in resp["results"]:
        print(f"  {entry['event_id']}: {entry['count']} segments pulled")

# 1. Speaker identity and stats (unmetered)
speaker = requests.get(
    f"{BASE}/v1/speakers/{SPEAKER_ID}", headers=HEADERS
).json()
stats = requests.get(
    f"{BASE}/v1/speakers/{SPEAKER_ID}/stats", headers=HEADERS
).json()

print(f"{speaker['canonical_name']} ({speaker['event_count']} events)")
speaking = stats["speaking_time"]
qa = stats["as_primary_speaker"]
print(f"  Total speaking time: {speaking['total_speaking_ms'] / 60000:.0f} minutes")
print(f"  Events appeared in: {speaking['events_appeared_in']}")
print(f"  Q&A events: {qa['qa_event_count']}, avg questions: {qa['avg_questions_per_event']:.1f}")

# 2. All their events (unmetered)
events = requests.get(
    f"{BASE}/v1/speakers/{SPEAKER_ID}/events", headers=HEADERS
).json()

# 3. Discover which topics this speaker covers most
from collections import Counter
topic_counts = Counter()
for event in events:
    topics = requests.get(
        f"{BASE}/v1/events/{event['event_id']}/topics", headers=HEADERS
    ).json()
    for t in topics:
        topic_counts[t["slug"]] += 1

print(f"\nTop topics:")
for slug, count in topic_counts.most_common(10):
    print(f"  {slug}: {count} events")

from datetime import date, timedelta

TOPIC = "tariffs"
start = date(2026, 1, 1)
end = date(2026, 6, 1)

# Walk month by month
current = start
while current < end:
    month_end = (current.replace(day=28) + timedelta(days=4)).replace(day=1)
    if month_end > end:
        month_end = end

    segments = []
    cursor = None
    while True:
        params = {
            "start_date": current.isoformat(),
            "end_date": month_end.isoformat(),
            "limit": 200,
        }
        if cursor:
            params["cursor"] = cursor
        resp = requests.get(
            f"{BASE}/v1/topics/{TOPIC}/segments",
            headers=HEADERS, params=params,
        ).json()
        segments.extend(resp["data"])
        cursor = resp.get("next_cursor")
        if not cursor:
            break

    event_ids = set(s["event_id"] for s in segments)
    print(f"{current.strftime('%Y-%m')}: {len(segments)} segments across {len(event_ids)} events")
    current = month_end