Open Post

Run your social media on autopilot, on your own server.

A free, MIT-licensed, self-hosted social media scheduler and AI autopilot for X, LinkedIn, Reddit, Bluesky and webhooks.
It's one Node.js process with one SQLite file. No Redis, no Temporal, no paid tier.

Website · Quickstart · Docs / Wiki · API · Compare vs Postiz · FAQ

• Why Open Post?
• Features
• Quickstart
• Your first post in five minutes
• Connecting real channels
• Autopilot
• AI providers
• Configuration reference
• REST API
• How it works
• Deployment
• Security
• Open Post vs Postiz
• Roadmap
• FAQ
• Contributing
• License

Most social media schedulers fall into one of two camps. Hosted SaaS tools charge per channel or per seat and keep your content on their servers. The open-source alternatives are often full platforms that need PostgreSQL, Redis, a workflow engine and several containers before you can schedule a single post.

Open Post is for people who want just enough:

• Write once, publish everywhere. Write a post once, tweak it per platform if you like, and pick a time. Open Post publishes it to every channel you selected and logs exactly what happened on each one.
• Autopilot when you're busy. Give it a list of topics and a few daily time slots. It drafts posts, with an LLM or its offline template engine, and keeps your calendar filled.
• Own everything. Your posts live in a single SQLite file on your machine, and your API keys live in environment variables. There are no accounts to create and nothing phones home.
• Small enough to understand. The whole backend is a handful of files and has one runtime dependency (Express). You can read it in an afternoon and change anything.

It runs happily on a small VPS, a Raspberry Pi, a home server or your laptop. We measured about 70 MB RSS at idle on Node 20.

Status: v1.1 is a young project. Everything described in this README is implemented and covered by tests. Planned features are listed in the roadmap and labelled as such. Nothing in the app is mocked. See AUDIT.md for how the original prototype's mock data was removed.

• Universal composer with optional per-platform versions for X, LinkedIn, Reddit (title and body) and Bluesky
• Live character counters for X (280), Bluesky (300) and LinkedIn (3000). Posts over a limit are rejected, never silently cut
• X threads: put a line containing --- between parts and they're posted as a reply chain
• Queue and calendar views: filter by status, edit, reschedule, publish now, or click a calendar day to schedule
• Delivery log per channel, with remote IDs and links to the live post
• Automatic retries with exponential backoff (1 → 2 → 4 minutes). Only the channels that failed are retried
• Clear post states: draft, scheduled, publishing, published, partial, failed

You can run multiple accounts per network by giving each channel its own env prefix (for example X_BRAND2_API_KEY).

• Cadence slots (e.g. 09:00, 13:00, 17:30), planned 1–14 days ahead without double-booking
• Topic queue with content pillars. Evergreen topics are recycled when the one-off ideas run out
• Five personas: Thought Leader, Indie Hacker / Builder in Public, Technical Architect, Contrarian Analyst, Viral Storyteller
• Platform-tailored output: one idea becomes an X post, a LinkedIn post, a Reddit title and body, and a Bluesky post
• Transparent: every generated post records which engine wrote it and, if a provider failed, why it fell back

• OpenAI (and any OpenAI-compatible endpoint), Anthropic, Google Gemini, and Ollama for fully local models
• Built-in heuristic engine that needs no API key and no network, and gives deterministic output

• Storage: built-in node:sqlite on Node 22+, better-sqlite3, or an atomic JSON file. Detected automatically
• Sandbox mode for safe end-to-end testing (SANDBOX_MODE=true)
• Optional API token that protects the API and dashboard
• Docker image runs as a non-root user with a healthcheck
• cli.js tick for cron or serverless-style runs
• OpenAPI 3.1 spec, llms.txt and CITATION.cff for tools and agents

Composer	Autopilot
Calendar	Channels: shows which env vars are missing, never the values

git clone https://github.com/CodesbyFebin/Open-Post.git
cd Open-Post
cp .env.example .env
# for a first, risk-free run:
sed -i 's/^SANDBOX_MODE=false/SANDBOX_MODE=true/' .env
docker compose up -d --build

Open http://localhost:3000.

git clone https://github.com/CodesbyFebin/Open-Post.git
cd Open-Post
npm install
cp .env.example .env
npm start

curl http://localhost:3000/api/health
# {"status":"ok","app":"open-post","version":"1.1.0","store":"node:sqlite","sandboxMode":true,...}

The store field shows which storage engine was picked: node:sqlite, better-sqlite3 or json.

1. Start in sandbox mode (SANDBOX_MODE=true). The header shows SANDBOX MODE so you always know nothing is going out.
2. Add a channel. Open Channels, pick sandbox (or any real type) and give it a name.
3. Compose. Open Compose, write something, tick the channel and pick a time a minute or two from now. Then click Schedule.
4. Watch it go out. The scheduler checks every 30 seconds. In Queue, the post changes to published and the delivery log shows sandbox (not sent).
5. Go live. Add the credentials for a real network to .env (see below), set SANDBOX_MODE=false, restart, and publish for real.

Prefer the terminal? Here's the same flow with curl:

B=http://localhost:3000
CH=$(curl -s -X POST $B/api/channels -H 'Content-Type: application/json' \
      -d '{"type":"sandbox","name":"Try it"}' | node -pe 'JSON.parse(require("fs").readFileSync(0)).id')

curl -s -X POST $B/api/posts -H 'Content-Type: application/json' \
  -d "{\"content\":\"Hello from Open Post\",\"channelIds\":[\"$CH\"]}" > /tmp/post.json

curl -s -X POST $B/api/posts/$(node -pe 'require("/tmp/post.json").id')/publish-now

Open Post never stores secrets in its database. Each channel reads its credentials from environment variables named <PREFIX>_<KEY>. The dashboard shows which variables are still missing. It shows only the names, never the values.

Quick notes for each network (the Channels wiki page has step-by-step instructions):

• X: your app needs Read and write permission. Regenerate the access token after changing permissions. An app-only Bearer token can't create posts. X's API tiers and pricing change, so check that your plan allows writes.
• LinkedIn: use a token with w_member_social (personal) or w_organization_social (company page). The author is urn:li:person:<id> or urn:li:organization:<id>. Tokens usually expire after about 60 days.
• Reddit: create a script app at reddit.com/prefs/apps, and set a descriptive REDDIT_USER_AGENT. Each subreddit's rules still apply.
• Bluesky: use an App Password, never your main password. Links and #hashtags become clickable automatically.
• Webhooks: perfect for n8n, Make, Zapier or your own service. Each request carries X-Open-Post-Signature: sha256=<hmac>, so you can verify it came from you.

Multiple accounts: create a second X channel with env prefix X_BRAND2 and set X_BRAND2_API_KEY, X_BRAND2_API_SECRET, X_BRAND2_ACCESS_TOKEN and X_BRAND2_ACCESS_SECRET.

Autopilot turns a list of ideas into a steady posting schedule.

1. Add topics in the Autopilot tab, e.g. "What we learned migrating to SQLite" (pillar: Engineering). Tick evergreen for topics that are fine to revisit.
2. Pick a persona to set the tone of voice.
3. Choose target channels and cadence slots, e.g. 09:00, 18:00. Slots use the server's local time, so set TZ.
4. Enable it. Every five minutes Open Post looks horizonDays ahead, finds empty slots, picks the least-used eligible topic, drafts a post and schedules it.

Autopilot posts are normal scheduled posts. You can review, edit or delete them before they're due. If you'd rather approve everything by hand, leave autopilot disabled and press Fill slots now or Generate one now when you want drafts.

When the queue is empty, autopilot simply stops. It never makes up topics.

Override the model with AI_MODEL. The prompt asks for a core post plus variants for X, LinkedIn, Reddit and Bluesky, and tells the model not to invent statistics, customers or testimonials. If a provider errors or returns invalid JSON, Open Post uses the heuristic engine and saves the reason in meta.fallbackReason. The UI shows it too, so silent failures are impossible.

Configuration lives in environment variables, usually a .env file. .env.example lists all of them with comments. The most important ones:

The dashboard uses the same API you do. The full spec is in openapi.yaml, and you can load it into Swagger UI, Postman, Insomnia or an AI agent.

Example: schedule a post that goes out as a two-part thread on X and a single post elsewhere:

curl -X POST http://localhost:3000/api/posts -H 'Content-Type: application/json' -d '{
  "content": "We just shipped Open Post 1.1: real drivers, SQLite and autopilot.",
  "platformOverrides": {
    "x": { "content": "We just shipped Open Post 1.1 🚀\n---\nReal X, LinkedIn, Reddit and Bluesky drivers, SQLite storage and an autopilot that fills your calendar." },
    "reddit": { "title": "Open Post 1.1: a tiny self-hosted social scheduler" }
  },
  "channelIds": ["ch_x...", "ch_bsky...", "ch_reddit..."],
  "scheduledFor": "2026-11-01T09:00:00+05:30",
  "tags": ["release"]
}'

┌──────────────── one Node.js process ────────────────┐
│                                                     │
│  Dashboard (public/)  ──►  REST API (src/app.js)    │
│                               │                     │
│                     Service (src/service.js)        │
│              posts · channels · retries · autopilot │
│                 │              │             │      │
│        Store (src/store.js)  Drivers       LLM      │
│        SQLite / JSON file    X · LinkedIn  OpenAI · │
│                              Reddit ·      Anthropic│
│   Scheduler (setInterval)    Bluesky ·     Gemini · │
│   fill slots → dispatch due  Webhook ·     Ollama · │
│                              Sandbox       Heuristic│
└─────────────────────────────────────────────────────┘

• No queue server. A single timer ticks every 30 seconds. A guard stops two ticks from overlapping, and an in-flight lock stops a post from being published twice.
• No ORM. Records are JSON documents in a single SQLite table keyed by (collection, id), so the same code runs on SQLite or a JSON file.
• Drivers are plain functions of (channel, post, { fetch, env }). The tests inject a fake fetch and check the exact HTTP request each network receives.

• Any VPS or home server: Docker Compose, or Node with systemd. See the Installation and Deployment wiki pages.
• Behind HTTPS: put Caddy or Nginx in front, set HOST=127.0.0.1 and set API_TOKEN.
• Backups: sqlite3 data/open-post.db ".backup backup.db", or copy data/open-post.json.
• One instance per data directory. The scheduler is in-process.
• Hosts that sleep idle containers will pause the scheduler too. Use an always-on host, or trigger node cli.js tick from cron.

• Secrets come only from environment variables. The API rejects credentials in channel payloads and never returns secret values.
• Setting API_TOKEN protects the API and dashboard with a constant-time token check.
• Webhooks are HMAC-signed when WEBHOOK_SECRET is set.
• Open Post is single-tenant. Anyone with API access can post to every connected channel, so keep it private or token-protected.
• Report vulnerabilities privately. See SECURITY.md.

Postiz is a mature, full-featured open-source scheduler, and if you need what it offers, it's a great choice. Open Post makes different trade-offs:

_{The Postiz column comes from its self-hosting documentation (System Requirements and Configuration Reference), checked in October 2026. If something has changed, please open an issue.}

Choose Open Post if you post to a few networks as one person or a small team, want tiny resource usage, or want code you can read end to end. Choose Postiz if you need many networks, media, team workflows or a hosted service.

These are planned and not implemented yet:

• Image and video uploads (X, LinkedIn, Bluesky blobs)
• OAuth "Connect" buttons as an alternative to env vars
• Mastodon and Threads drivers
• Engagement metrics pulled back from each network
• Per-slot channel targeting and per-day cadences
• Approval queue for autopilot posts
• Prebuilt container image on GHCR

Want one of these? Comment on or open an issue, or send a PR.

Contributions of all sizes are welcome: bug reports, docs fixes, new drivers and UI polish.

npm install
npm test        # node --test
npm run lint    # eslint
npm run dev     # auto-restart on changes

Please read CONTRIBUTING.md and follow the Code of Conduct. Good first contributions: a Mastodon driver, media uploads for Bluesky, translations for the dashboard, and more tests.

If Open Post saves you time, starring the repo helps other people find it.

MIT. Free for personal and commercial use.