---
title: Getting Started
description: Go from signup to your first API call in under 10 minutes.
---

## What is PostGrad?

PostGrad is the knowledge layer for AI agents. It extracts structured business knowledge from meeting transcripts and delivers it through a REST API and MCP server.

Every knowledge entry is categorized, tagged, and assigned a confidence score that increases as the same insight is reinforced across multiple meetings. Your AI agents stay current with real business context -- not stale documentation.

## Prerequisites

Before you begin, you need:

- A **PostGrad account** at [postgrad.io](https://postgrad.io)
- An active **subscription** (Starter, Pro, or Scale)
- An **API key** from your dashboard

## Step 1: Sign Up and Subscribe

Visit [postgrad.io](https://postgrad.io) and create an account. Choose a plan that fits your needs:

| Plan | Rate Limit | Monthly Quota | Search Modes |
|------|-----------|---------------|--------------|
| **Starter** | 20 req/min | 1,000/month | Keyword + Semantic + Hybrid |
| **Pro** | 60 req/min | 10,000/month | Keyword + Semantic + Hybrid |
| **Scale** | 200 req/min | 50,000/month | Keyword + Semantic + Hybrid |

All tiers have access to every feed and category they're subscribed to, and to every search mode (keyword, semantic, hybrid). Tiers differ only in rate limits, monthly quotas, and ops features (webhooks, support) — not retrieval capability.

## Step 2: Get Your API Key

After subscribing, navigate to your [Dashboard](https://postgrad.io/dashboard) and create an API key. Your key will have a `pg_live_` prefix:

```
pg_live_abc123def456...
```

**Important:** Copy your key immediately. For security, the full key is only shown once.

## Step 3: Make Your First Request

Knowledge requests need two headers: your API key **and** a `X-PostGrad-Feed` header identifying which feed to query. Find your feed ids by calling `GET /api/v1/feeds` (only requires the API key):

```bash
curl -X GET "https://postgrad.io/api/v1/feeds" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY"
```

Then use one of the returned feed ids to list knowledge entries:

```bash
curl -X GET "https://postgrad.io/api/v1/knowledge?limit=5" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY" \
  -H "X-PostGrad-Feed: YOUR_FEED_UUID"
```

The response follows a consistent envelope:

```json
{
  "data": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "title": "AI agent architecture uses RAG with vector embeddings",
      "category": "ai_architecture",
      "content": "The AI agent architecture uses retrieval-augmented generation...",
      "tags": ["rag", "vector-embeddings", "supabase"],
      "confidence": 0.85,
      "reinforcement_count": 3,
      "created_at": "2026-03-15T10:30:00Z",
      "updated_at": "2026-04-01T14:22:00Z"
    }
  ],
  "pagination": {
    "total": 142,
    "limit": 5,
    "offset": 0,
    "has_more": true
  },
  "meta": {
    "queries_used": 1,
    "queries_remaining": 999
  },
  "error": null
}
```

## Step 4: Search the Knowledge Base

Use full-text search to find specific insights:

```bash
curl -X GET "https://postgrad.io/api/v1/knowledge/search?q=pricing%20strategy" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY" \
  -H "X-PostGrad-Feed: YOUR_FEED_UUID"
```

**Shortcut:** If you omit `X-PostGrad-Feed`, PostGrad auto-picks your most-populated subscribed feed and returns which one it used in the `X-PostGrad-Feed-Auto-Selected` response header. Great for exploratory queries from LLMs; pass the header explicitly when you know which feed you want.

**Search all your feeds:** Pass `X-PostGrad-Feed: all` (or `?feed=all`) to search every feed you're subscribed to and get merged, relevance-ranked results. Each hit includes `feed_id` + `feed_name` so you can see which feed answered. One fan-out = one request against your monthly quota.

```bash
curl -X GET "https://postgrad.io/api/v1/knowledge/search?q=pricing%20strategy" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY" \
  -H "X-PostGrad-Feed: all"
```

Filter by category to narrow results:

```bash
curl -X GET "https://postgrad.io/api/v1/knowledge/search?q=pricing&categories=deal_evaluation,sales_process" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY" \
  -H "X-PostGrad-Feed: YOUR_FEED_UUID"
```

## Step 5: Check Your Usage

Monitor your API consumption for the current billing period:

```bash
curl -X GET "https://postgrad.io/api/v1/usage" \
  -H "Authorization: Bearer pg_live_YOUR_API_KEY"
```

```json
{
  "data": {
    "period_start": "2026-04-01T00:00:00Z",
    "period_end": "2026-05-01T00:00:00Z",
    "queries_used": 42,
    "queries_limit": 1000,
    "queries_remaining": 958,
    "tier": "starter"
  },
  "meta": {
    "queries_used": 42,
    "queries_remaining": 958
  },
  "error": null
}
```

## Explore Public Endpoints

Two endpoints are available without authentication:

**List categories** -- discover what knowledge domains are available:

```bash
curl -X GET "https://postgrad.io/api/v1/categories"
```

**Get statistics** -- see the size and freshness of the knowledge base:

```bash
curl -X GET "https://postgrad.io/api/v1/stats"
```

## Authentication Options

PostGrad supports two authentication methods:

**Bearer token** (recommended):

```bash
Authorization: Bearer pg_live_YOUR_API_KEY
```

**Header key** (alternative):

```bash
x-api-key: pg_live_YOUR_API_KEY
```

Both methods work identically. Use whichever fits your HTTP client.

## Next Steps

- [API Reference](/docs/api) -- Complete endpoint documentation with interactive explorer
- [MCP Integration](/docs/mcp-integration) -- Connect PostGrad to AI agents via MCP
- [SDKs](/docs/sdks) -- Python and TypeScript client libraries