Pregame API

What you can build

The Pregame API surfaces readiness signals for any meeting — company overview, key people, talking points, objection prep, competitive context, and trigger events from the last 30 days. It connects to your CRM and calendar so signals flow where your team already works.

Authentication

All API requests require an API key. Create yours at pregame.io/api-keys. Keys are prefixed pg_live_ for production.

Pass your key in either header:

# Option 1: Authorization header (recommended)
Authorization: Bearer pg_live_your_key_here

# Option 2: X-API-Key header
X-API-Key: pg_live_your_key_here

Quickstart — 5 minutes

Generate your first readiness brief end-to-end:

1. Get an API key at pregame.io/api-keys after signing up. Keys are available immediately on any paid plan.

2. Make your first call — pass a company name and any available prospect context. The brief returns in under 5 seconds.

3. Use the brief — surface it in Slack, push to your CRM, or display it in your product. The brief_id lets you retrieve scores and track outcomes later.

curl -X POST https://pregame.io/api/v1/brief \
  -H "Authorization: Bearer pg_live_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "prospect_company": "Acme Corp",
    "prospect_name": "Sarah Chen",
    "prospect_email": "sarah@acmecorp.com",
    "context": "Leads RevOps. 200-person B2B SaaS, Series B."
  }'

const res = await fetch('https://pregame.io/api/v1/brief', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer pg_live_your_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    prospect_company: 'Acme Corp',
    prospect_name: 'Sarah Chen',
    prospect_email: 'sarah@acmecorp.com',
    context: 'Leads RevOps. 200-person B2B SaaS, Series B.'
  })
});
const { brief_id, brief, credits_remaining } = await res.json();
console.log(brief.talking_points); // → ["...", "...", ...]
console.log(`Score queryable at: /api/v1/score/${brief_id}`);

import requests

res = requests.post(
    'https://pregame.io/api/v1/brief',
    headers={
        'Authorization': 'Bearer pg_live_your_key_here',
        'Content-Type': 'application/json'
    },
    json={
        'prospect_company': 'Acme Corp',
        'prospect_name': 'Sarah Chen',
        'prospect_email': 'sarah@acmecorp.com',
        'context': 'Leads RevOps. 200-person B2B SaaS, Series B.'
    }
)
data = res.json()
print(data['brief']['talking_points'])

POST /v1/brief

Generates a complete meeting readiness brief for a prospect. The core endpoint. Consumes 1 credit per call.

Request body

Response

{
  "success": true,
  "brief_id": "b_8x92ka4f",
  "credits_remaining": 14,
  "brief": {
    "prospect_summary": "Acme Corp is a 200-person RevOps platform focused on...",
    "key_people": [
      { "name": "Sarah Chen", "role": "VP RevOps", "linkedin": "..." }
    ],
    "talking_points": [
      "Series B raise (Jan 2026) signals budget for tooling investment...",
      "Their RevOps team of 3 handles 450+ reps — scale pain is documented..."
      // 3 more...
    ],
    "objection_prep": [
      {
        "objection": "We already have something for this",
        "response": "Most teams using Gong are solving post-call — Pregame is pre-call..."
      }
    ],
    "trigger_events": [
      {
        "headline": "Acme Corp names new CRO",
        "date": "2026-05-10",
        "relevance": "New CRO typically accelerates tooling evaluations within 90 days"
      }
    ],
    "competitive_context": "Currently trialing Clari for forecasting, open to point solutions...",
    "follow_up_draft": "Hi Sarah, great talking today...",
    "pregame_score": 74
  }
}

GET /v1/score/:brief_id

Retrieves the full Pregame Score for a brief — including all 6 component scores, risk indicators, and scoring rationale.

{
  "success": true,
  "brief_id": "b_8x92ka4f",
  "score": {
    "total": 74,
    "band": "good",
    "components": {
      "company_intel":   { "score": 82, "weight": 0.20 },
      "person_intel":    { "score": 71, "weight": 0.20 },
      "trigger_events":  { "score": 90, "weight": 0.15 },
      "talking_points":  { "score": 68, "weight": 0.20 },
      "objection_prep":  { "score": 65, "weight": 0.15 },
      "competitive":     { "score": 58, "weight": 0.10 }
    },
    "risk_indicators": [
      "No LinkedIn profile — person-level context limited",
      "Competitive landscape unknown — budget conversation may be contested"
    ],
    "scored_at": "2026-05-18T14:22:35Z"
  }
}

API Key Management

Manage API keys via the dashboard at api-keys or programmatically. All key management endpoints require user session authentication (not an API key).

GET /v1/usage

{
  "success": true,
  "total": 47, "limit": 20, "offset": 0,
  "briefs": [
    {
      "brief_id": "b_8x92ka4f",
      "prospect_company": "Acme Corp",
      "prospect_name": "Sarah Chen",
      "pregame_score": 74,
      "generated_at": "2026-05-18T14:22:33Z"
    }
  ]
}

Pregame Score — Overview

The Pregame Score is a 0–100 readiness signal that quantifies how well a rep can walk into a meeting. It's built from 6 weighted components across company intelligence, people intelligence, trigger events, talking point quality, objection coverage, and competitive context.

Score Components

Risk indicators flag specific gaps: missing LinkedIn, unknown tech stack, no recent news, undifferentiated objection responses. These appear in score.risk_indicators[].

Querying Scores

After brief generation, the brief_id is the persistent handle. Use it to retrieve the score, attach outcomes, and pull the brief back into your tooling.

curl https://pregame.io/api/v1/score/b_8x92ka4f \
  -H "Authorization: Bearer pg_live_your_key_here"

const { score } = await fetch(
  `https://pregame.io/api/v1/score/${briefId}`,
  { headers: { 'Authorization': `Bearer ${PREGAME_KEY}` } }
).then(r => r.json());

console.log(score.total);      // → 74
console.log(score.band);       // → "good"
console.log(score.risk_indicators); // → ["No LinkedIn profile..."]

Attendance Signals

Postgame collects attendance and meeting quality signals after the call. For calendar-connected users (Google or Outlook), Pregame polls the calendar event post-meeting to detect attended vs. no-show. HubSpot-connected users also get call duration from the Engagements API.

Signals are collected automatically for calendar-connected accounts. No additional API calls required — they appear in the outcome record and analytics automatically.

Outcome Tracking

Record deal outcomes against meetings to unlock win-rate analysis segmented by Pregame Score. Outcomes are linked to CRM deals automatically when HubSpot or Salesforce is connected.

Win-Rate Analytics

{
  "success": true,
  "bands": [
    { "band": "excellent", "meetings": 23, "won": 16, "win_rate": 0.70 },
    { "band": "good",      "meetings": 41, "won": 22, "win_rate": 0.54 },
    { "band": "fair",      "meetings": 38, "won": 12, "win_rate": 0.32 },
    { "band": "poor",      "meetings": 19, "won": 4,  "win_rate": 0.21 }
  ]
}

Webhooks — Overview

Webhooks are how integrations like Calendly, Instantly, Apollo, Pipedrive, Close CRM, HubSpot, and Salesforce push events into Pregame to trigger brief generation or outcome recording automatically. No polling required.

The general pattern:

1. A meeting books or a deal closes in your external tool
2. The tool sends a webhook to the Pregame endpoint
3. Pregame validates the signature, generates a brief, emails the rep, and optionally pushes back to the CRM

Webhook Event Reference

Example: Calendly payload (invitee.created)

{
  "event": "invitee.created",
  "payload": {
    "event_type": { "name": "30 Min Discovery Call" },
    "invitee": {
      "name": "Sarah Chen",
      "email": "sarah@acmecorp.com"
    },
    "scheduled_event": {
      "start_time": "2026-05-20T14:00:00Z"
    }
  }
}

Webhook Security

Every inbound webhook is validated with HMAC-SHA256 signatures. Requests with missing or invalid signatures are rejected with 401. The signing secret is set per-integration in your Pregame dashboard.

const crypto = require('crypto');

function verifySignature(rawBody, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(expected),
    Buffer.from(signature)
  );
}

// In your Express handler:
app.post('/webhooks/pregame', express.raw({ type: '*/*' }), (req, res) => {
  const sig = req.headers['x-webhook-signature'];
  if (!verifySignature(req.body, sig, process.env.WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  // process event...
});

Signature header by platform

Retry Behavior

Pregame's webhook endpoints are designed to be idempotent. For inbound webhooks, return 200 immediately — even before processing — to prevent the sender from retrying.

Integration — Calendly

When a prospect books via your Calendly link, Pregame auto-generates a brief and emails it to you — before the meeting.

1. Connect Calendly in Settings → Integrations → Calendly. Enter your Calendly webhook signing secret.

2. Register the webhook URL in Calendly → Integrations → Webhooks. Set the URL to https://pregame.io/api/webhooks/calendly/YOUR_USER_ID and subscribe to invitee.created and invitee.canceled.

3. Set the signing secret — copy the secret from Calendly and paste into Pregame's Calendly integration settings.

4. Test it — book a test event on your Calendly link. A brief should appear in your email within 30 seconds.

Integration — Apollo

When a lead books a meeting in Apollo, Pregame auto-generates a brief and optionally pushes 4 enriched fields back to the Apollo contact record.

1. Connect Apollo in Settings → Integrations → Apollo. Enter your Apollo API key.

2. Set up webhook in Apollo → Integrations → Webhooks. Point to https://pregame.io/api/webhooks/apollo/YOUR_USER_ID. Subscribe to meeting_booked.

3. Enable field write-back (optional) — Pregame pushes brief summary, score, talking points, and trigger events to 4 configurable custom fields on the Apollo contact via PUT /api/v1/contacts/:id.

Integration — Instantly

Auto-generate briefs when Instantly leads reply and book. Works via Instantly's webhook on reply events.

// Forward Instantly reply webhook to Pregame brief generation
app.post('/webhooks/instantly-reply', async (req, res) => {
  res.json({ ok: true }); // ack immediately

  const { lead_email, lead_name, lead_company } = req.body;
  const data = await fetch('https://pregame.io/api/v1/brief', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.PREGAME_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      prospect_company: lead_company,
      prospect_name: lead_name,
      prospect_email: lead_email,
      context: 'Replied to cold outreach. Booking confirmed.'
    })
  }).then(r => r.json());

  // Slack the rep, push to CRM, etc...
});

Integration — HubSpot

Pregame connects to HubSpot via OAuth for read-only contact and deal enrichment. When generating a brief, Pregame automatically looks up the prospect's contact record and associates open deals — no manual linking needed.

1. Connect HubSpot in Settings → Integrations → HubSpot. Click "Connect with HubSpot" and complete the OAuth flow. Read-only access is requested.

2. Deal linkage fires automatically — after each brief, Pregame queries HubSpot for a contact matching prospect_email and finds associated open deals via the Associations API.

3. Outcome webhooks (optional) — for win/loss tracking, configure a HubSpot workflow to POST to https://pregame.io/api/webhooks/hubspot/deal-stage when a deal stage changes to closedwon or closedlost.

Integration — Salesforce

Full OAuth 2.0 Connected App integration. Reads contacts and open opportunities. After debrief, writes a completed Task and updates Opportunity.NextStep. AppExchange install available for enterprise accounts.

1. Install the Connected App via https://pregame.io/auth/salesforce/install (AppExchange) or connect in-app at Settings → Integrations → Salesforce.

2. Complete OAuth — you'll be redirected to Salesforce to authorize. Both production and sandbox orgs are supported (set SALESFORCE_ENVIRONMENT=sandbox for sandbox).

3. Deal linkage fires automatically — Pregame queries contacts by email → resolves AccountId → finds open opportunities (IsClosed=false), preferring the most recently active deal.

4. Outcome webhooks — use Salesforce Flow to POST to /api/webhooks/salesforce when Opportunity.StageName changes. Validate the SALESFORCE_WEBHOOK_SECRET signature.

AppExchange External Services

For Salesforce AppExchange partners, Pregame provides an OpenAPI 3.0 schema for Salesforce External Services integration:

Integration — Pipedrive

Webhook-triggered briefs on activity.added and deal.added events. Optional write-back pushes a note to the Pipedrive person and deal records.

1. Connect Pipedrive in Settings → Integrations → Pipedrive. Enter your Pipedrive API token and webhook signing secret.

2. Configure webhooks in Pipedrive → Tools → Webhooks. Add a webhook for activity.added pointing to https://pregame.io/api/webhooks/pipedrive/YOUR_USER_ID.

3. Enable note write-back (optional) — Pregame pushes brief summary and top 3 talking points as a note on both the Pipedrive person and deal record.

Integration — Close CRM

Triggered on activity_meeting.created. Brief is generated, emailed to the rep, and (optionally) pushed as a note to the Close lead via the Close REST API.

1. Connect Close in Settings → Integrations → Close. Enter your Close API key and webhook signing secret.

2. Configure webhook in Close → Settings → Webhooks. Subscribe to activity.meeting.created and point to https://pregame.io/api/webhooks/close/YOUR_USER_ID.

3. Enable push to Close (optional) — pushes the brief summary and top 3 talking points as a note on the Close lead. Uses HTTP Basic Auth with your Close API key.

Integration — Slack

Brief delivery to a Slack channel via OAuth bot token. Briefs are posted as Block Kit messages with prospect name, company, top 3 talking points, Pregame Score, and a "View Full Brief" button.

1. Connect Slack in Settings → Integrations → Slack. Click "Add to Slack" and authorize the bot in your workspace.

2. Select a channel — choose where briefs should be delivered. Briefs go to the configured channel automatically when auto_deliver is enabled.

3. Configure delivery triggers — set whether briefs are posted on generation, or only for calendar-linked meetings.

Integration — Google Calendar

OAuth connection for automatic meeting detection. Pregame polls every 15 minutes for upcoming external meetings and auto-generates briefs 24 hours before the meeting.

1. Connect Google in Settings → Integrations → Google Calendar. Complete the OAuth flow — read-only access to calendar events is requested.

2. External meeting detection — Pregame identifies meetings with attendees outside your domain. Company is inferred from attendee email domains.

3. Auto-prep window — briefs are generated 24 hours before the meeting and emailed to you automatically.

Integration — Outlook

Same auto-prep behavior as Google Calendar, via Microsoft OAuth. Tokens are refreshed automatically before expiry using a 7-day external detection window.

1. Connect Outlook in Settings → Integrations → Outlook. Authorize via Microsoft OAuth.

2. External detection — Pregame detects meetings with external attendees (outside your domain) using a 7-day lookahead window.

3. Token refresh — tokens are refreshed automatically before expiry. Re-authorization is only needed if the token is revoked manually.

Rate Limits

Each API key is limited to 60 requests per minute. Limits are per-key, not per-account.

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 57
X-RateLimit-Reset: 2026-05-18T14:23:00.000Z

On 429 Too Many Requests, wait for the X-RateLimit-Reset timestamp before retrying. Need higher throughput? Contact us for volume pricing with elevated limits.

Error Codes

All errors return a consistent JSON structure:

{
  "success": false,
  "error": "No credits remaining. Please upgrade your plan.",
  "code": "INSUFFICIENT_CREDITS"
}

Versioning

The API is versioned with a /v1/ prefix. The current stable version is v1. When breaking changes are introduced, they will be published under a new version prefix with a 90-day deprecation window for v1.

Credits & Billing

Each call to POST /v1/brief costs 1 credit. Credits are tied to your Pregame plan and reset monthly.

POST /v1/brief returns credits_remaining in every response. Monitor programmatically. On exhaustion the API returns 402. Need more than 100 calls/month? Contact us for volume pricing.