# Quickstart · PostLake Docs

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

This is the from-scratch walkthrough. By the end you'll have a real post live on a real social account. **No prior experience with APIs is assumed** — if a step needs a word explained, it explains it.

 **Two ways to post, and you'll set up both.** First we publish straight from the PostLake dashboard with **no code** (steps 1–3) — good for a quick check that everything works. Then we do the same thing through the **API** (steps 4–6), which is how your own app or an AI agent posts automatically. Do the no-code part first; it makes the API part obvious.

## 1. Create your PostLake account

 - Go to [app.postlake.dev](https://app.postlake.dev) and sign up with your email (or your Google / GitHub account).

 - Check your inbox for a verification email and click the link inside. This unlocks your **free credits** — enough to try everything here without paying.

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

## 2. Connect a social account

PostLake can only post to accounts you've connected. Let's connect one.

 - Open the **Channels** page from the top menu.

 - First make a **profile**. A profile is just a named folder for the accounts that belong together — a brand, a client, or simply "me". Type a name like `my-brand` and click **Add profile**.

 - Under that profile, find **Connect an account** and click the network you want. **Bluesky is the easiest to start with** — it needs no approval and connects in a few seconds.

 - A small window opens with exact steps (for Bluesky it walks you through creating an "app password"). Follow them, and the account appears connected under your profile.

 **Why Bluesky first?** Networks like Instagram, TikTok and Facebook require an app-review process before anyone can post to them through an API — that's their rule, not ours. Bluesky, Threads and others connect instantly, so they're the fastest way to see PostLake actually work. See [Platform support](https://postlake.dev/docs/platforms) for what each one needs.

## 3. Publish your first post — no code

 - Open the **Create** page from the top menu.

 - Tick the account you just connected, type a short message, and click **Publish**.

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

That's enough if you only ever post by hand. The rest of this page shows how to do the exact same thing **from code or an AI agent**, so it can happen automatically.

## 4. Get an API key

An **API key** is a long secret password that lets a program post on your behalf instead of you clicking buttons. Anything holding this key can act as you, so treat it like a password.

 - Click your account menu (top right) and open **API Keys**.

 - Optionally give it a name so you remember what it's for (e.g. `My first script`), then click **Create API key**.

 - Your key appears **once**, starting with `sk_live_…`. Copy it now and paste it somewhere safe — for security, PostLake can never show it again. If you lose it, just make a new one.

## 5. Make your first API call

The examples below use **curl** — a command that comes built into the Terminal app on Mac and Linux, and on Windows (PowerShell). It simply sends a request to PostLake over the internet. You don't have to use curl: any programming language, a tool like Postman, or your AI agent can send the same request. If you've never opened a terminal, curl is a gentle first taste — copy a line, paste it, press Enter.

Everywhere you see `YOUR_API_KEY`, swap in the key from step 4. Start by checking the key works — this asks PostLake "who am I?" and should return your account details:

```
# Paste this into your terminal (replace YOUR_API_KEY first)
curl https://api.postlake.dev/v1/me \
  -H "Authorization: Bearer YOUR_API_KEY"
```

If you get back a block of text with your account id in it, the key works. If you get a `401` error instead, the key is wrong or mistyped — go back to step 4. (The `Authorization: Bearer …` line is just how every request proves it's you; see [Authentication](https://postlake.dev/docs/authentication).)

## 6. Send a post through the API

Remember the **profile** you made in step 2 (say `my-brand`)? You post to it **by name** — the exact word you see in the dashboard. One call publishes to every account under that profile:

```
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"
  }'
```

Want just one network from that profile? Add a `platforms` filter — `"platforms": ["bluesky"]` posts to only its Bluesky account. That's the whole model: **post as a profile, optionally to certain platforms** — no ids to look up.

 **Need to target one exact account?** Every connected account also has a permanent id like `acc_7f3k9` (it never changes, even if you rename the account). List them with `GET /v1/social-accounts` and pass `"accounts": ["acc_7f3k9"]` instead of — or alongside — `profile`. Handy when an agent wants to be precise; for everyday use, a profile name is simpler.

You get back **the same shape for every platform** — one post id, plus a `targets` list with one entry per account telling you exactly what happened and the live URL:

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

 One account can fail (say, over its character limit) while the others succeed — you see it per target, and **you're only charged for the ones that actually publish**. Read the full lifecycle in [Publishing a post](https://postlake.dev/docs/publishing).

## 7. Add an image

Upload the image first — you get back an id like `med_…` — then include that id in a post's `media` list. Full detail (sizes, video, per-platform limits) is in [Media & images](https://postlake.dev/docs/media).

```
# Uploading returns { "id": "med_…" }
curl -X POST https://api.postlake.dev/v1/media \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: image/jpeg" \
  --data-binary @photo.jpg
```

## What's next

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

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

 - Wiring up an AI agent? Skip the keys entirely and use the [MCP server](https://postlake.dev/docs/mcp).

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