# Quickstart · PostLake Docs

> Markdown version of https://docs.postlake.dev/quickstart . The canonical page for humans.
> PostLake is the social media API for AI agents: https://postlake.dev/llms.txt

Get a real post live in minutes. PostLake is built agent-first, so the fastest path is to hand it to your AI assistant, but posting by hand or calling the API from your own code are here too. Pick your path:

Connect PostLake's hosted **MCP server** to your AI assistant, then just ask it to post. There's no API key to paste. The connection uses OAuth and signs you in through your browser.

```
https://api.postlake.dev/mcp
```

Pick your host for the exact steps:

 Claude Code

Add the server with one command, then approve the browser page that opens:

```
claude mcp add --transport http postlake https://api.postlake.dev/mcp
```

Start a fresh session and run `/mcp`, `postlake` should show as connected. Then just ask: *“Post ‘hello world’ to my Bluesky.”*

 Claude Desktop

Open **Settings → Connectors → Add custom connector**, paste the server URL above, and approve the browser sign-in. PostLake's tools then appear in any chat.

 Cursor

Open **Settings → Tools & MCP → New MCP server** (this opens `mcp.json`), merge this in, and save:

```
{
  "mcpServers": {
    "postlake": { "url": "https://api.postlake.dev/mcp" }
  }
}
```

Then find PostLake under **Settings → Tools & MCP**, connect it, and approve the browser sign-in.

 ChatGPT

In ChatGPT's developer mode / custom connectors, add a new MCP server pointing at the URL above, then approve the sign-in.

 Gemini CLI

```
gemini mcp add postlake https://api.postlake.dev/mcp
```

Then approve the browser page to authorize.

 VS Code · GitHub Copilot

In Copilot **Agent mode → MCP servers → Add**, point it at the URL above and sign in.

 Any other MCP host

Most hosts have an “add MCP server” action. Point it at `https://api.postlake.dev/mcp` with no `Authorization` header. It uses OAuth, so the host opens your browser to sign you in.

 **One-time setup:** your agent posts to accounts you've connected. Sign up at [app.postlake.dev](https://app.postlake.dev) and connect one on the **Channels** page, Bluesky is instant. After that, the agent handles publishing, scheduling and analytics on its own. Full detail in the [MCP guide](https://postlake.dev/mcp).

Post by hand from the PostLake dashboard, no code at all. Good for a quick check that everything works.

### 1. Create your account

 - Go to [app.postlake.dev](https://app.postlake.dev) and sign up with email, Google or GitHub. Verify your email to unlock your **free credits**.

 - You land on your **Dashboard**. The top menu, Channels, Create, Posts, Analytics, is where everything lives.

### 2. Connect a social account

 - Open **Channels** and make a **profile**: a named folder for accounts that belong together (a brand, a client, or just “me”). Type a name like `my-brand` and add it.

 - Under that profile, click **Connect an account** and pick a network. **Bluesky is easiest**: it needs no approval and connects in seconds.

 **Why Bluesky first?** Instagram, TikTok and Facebook need each platform's app-review before anyone can post through an API, their rule, not ours. Bluesky, Threads and others connect instantly. See [Platform support](https://postlake.dev/platforms).

### 3. Publish

 - Open **Create**, tick the account you connected, type a message, and click **Publish**.

 - Open that network in another tab. Your post is really there. That's the whole product in one screen.

Post from your own code in a few steps: get a key, then send a post. (Connect a social account first, see the **No code** tab.)

### 1. Get an API key

Sign up at [app.postlake.dev](https://app.postlake.dev), then open your account menu → **API Keys** → **Create API key**. It shows **once**, starting `sk_live_…`. Copy it somewhere safe. Treat it like a password.

### 2. Post your first message

Swap in your key and a connected **profile** name. One call publishes to every account under that profile:

```
# Replace YOUR_API_KEY and the profile name first
curl -X POST https://api.postlake.dev/v1/posts \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Hello from the PostLake API 👋",
    "profile": "my-brand"
  }'
```

```
import requests

# One call publishes to every account under the profile
res = requests.post(
    "https://api.postlake.dev/v1/posts",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "text": "Hello from the PostLake API 👋",
        "profile": "my-brand",  # the profile name from your dashboard
    },
)
print(res.json())
```

```
// One call publishes to every account under the profile
const res = await fetch("https://api.postlake.dev/v1/posts", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    text: "Hello from the PostLake API 👋",
    profile: "my-brand", // the profile name from your dashboard
  }),
});
console.log(await res.json());
```

### 3. Read the response

You get back **the same shape for every network**: one post id, plus a `targets` list with one entry per account and its live URL:

```
{
  "id": "post_a1b2c3",
  "state": "published",
  "targets": [
    { "platform": "bluesky", "state": "published", "url": "https://bsky.app/…" }
  ]
}
```

 An account can fail (say, over its character limit) while others succeed. You see it per target, and **you're only charged for the ones that actually publish**. Browse every endpoint in the [API reference](https://postlake.dev/api), or read the full lifecycle in [Publishing a post](https://postlake.dev/publishing).

## What's next

 - [Schedule](https://postlake.dev/scheduling) a post for later instead of publishing now.

 - Check [what each platform supports](https://postlake.dev/platforms) before you post to it.

 - Add [images or video](https://postlake.dev/media) to a post.

 - Browse every endpoint in the [API reference](https://postlake.dev/api).