Open-source project
trypostit/trypost avatar
trypostit/trypost

TryPost: the scheduler that publishes itself and takes direction from an agent

Open-source Social Media Scheduling

869 stars226 forksPHPAGPL-3.0

At a glance

What is it?
TryPost is an AGPL social media scheduler built on Laravel and Vue that publishes natively to twelve networks, keeps a brand profile it re-reads on every AI call, and exposes both a REST API and an MCP server so an assistant can draft, schedule and post. The self-hosting story is unusually well commented: the compose file exists to keep host and container agreeing on ownership, and the environment file explains billing switches like the one that defuses links on X.
Who is it for?
TryPost fits an agency or a technical solo operator who wants one calendar across many accounts, wants the copilot to write in a brand voice rather than a generic one, and would rather own the server than rent a seat. It does not fit someone who needs a single network done perfectly, because twelve integrations is twelve sets of platform-specific failure modes and the project does not document which of them are thin.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly PHP, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • trypostit/trypost869 ★ · +265
Star history
Repository2026-09-112026-11-15
trypostit/trypost604869

265 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Twelve native APIs instead of a handoff to the mobile app

The pitch is one calendar for every network: plan a month at a glance, drag a post to a different slot, and publish natively to twelve platforms. The networks are Instagram, Facebook, LinkedIn, X, TikTok, YouTube, Pinterest, Threads, Bluesky, Mastodon, Telegram and Discord, and the readme is explicit that each one goes through that platform's official API rather than a redirect or an instruction to finish the job in the mobile app. That distinction is the whole product for anyone who has used a scheduler that hands off, because a handoff means a person, a phone and a login for every post. The cost sits on the other side of the ledger and is worth stating plainly. Twelve integrations is twelve sets of token refresh, rate limits, media constraints and review processes, and a scheduler that publishes natively will fail in twelve different ways rather than one. The calendar itself offers month, week and day views with drag and drop rescheduling across networks, and the composer is built for the shape of the problem: write once, then tailor the preview for each network in parallel. Native analytics report per-account reach and engagement across every connected platform, which is the piece most self-hosted alternatives leave out.

X_DEFUSE_LINKS is a billing switch, and it is off by default

The clearest sign of how this project thinks about its self-hosted users is a single environment variable.

code
# Rewrite links in the X version of a post as non-clickable (example(.)com), so
# X does not bill them at the link-post rate. Self-hosted installs publish through
# their own X app and pay their own bill, so set true only if you want it.
X_DEFUSE_LINKS=false
META_PAGE_WALK_SECONDS=20

Setting it rewrites the links in the X version of a post into a form that is not clickable, so X does not bill the post at its link-post rate, and the comment is blunt about why the default is false: a self-hosted install publishes through its own X app and pays its own bill, so the switch is there for people who want the behaviour rather than people who need it. A scheduler that rewrites your links without telling you would be a nasty surprise, and one that exposes the switch in the environment file with the consequence written next to it is doing the opposite. The same neighbourhood of the file holds the other billing and account decisions. Self-hosted mode skips payment requirements and defaults to on, and there is a separate setting for allowing more than one connected account per network inside a workspace, which is independent of self-hosted mode, defaults to off on the cloud version and is written for self-hosted installs that want it true. A walk interval for Meta pages sits on the next line at twenty seconds. None of this appears in a feature list, and all of it changes what your posts do in production.

WEBHOOK_URL decides whether inbound callbacks ever reach you

Publishing outward is half the problem for a multi-network scheduler, because some networks answer by calling you back. The environment file has a variable for the public base URL those inbound webhooks are registered on, it defaults to the application URL, and for local development it is meant to be pointed at a tunnel URL. The default application URL in a fresh install is a localhost address, which means the callback registration points somewhere no external service can reach. Nothing crashes and nothing warns you: the post publishes, the platform accepts the reply, and the response that should come back never arrives. For the networks that need a callback this is the difference between a working install and a silent one, and it is the first thing to check when a Telegram or Discord connection connects and then does nothing. The same reasoning applies to the production deployment, where the variable has to be the real public origin rather than whatever the app thinks it is called internally. It is a small line in a long file of small lines, and it is the one that costs an afternoon when it is wrong.

The compose file is mostly about file ownership and test isolation

The development stack is three services and it is worth reading line by line, because each unusual entry answers a specific problem. Build arguments pass your user and group identifiers into the image so files the container writes belong to you and not to root, and the same two values are passed into the running container. Three volumes follow: the repository itself, a named volume for the installed PHP packages and another for the node packages, so what the image installs and what your laptop installed never overwrite each other.

code
        volumes:
            - .:/var/www/html
            - app-vendor:/var/www/html/vendor
            - app-node-modules:/var/www/html/node_modules
        extra_hosts:
            - 'host.docker.internal:host-gateway'
        depends_on:
            pgsql:
                condition: service_healthy
            redis:
                condition: service_healthy
        healthcheck:
            test: ['CMD', 'curl', '-fsS', 'http://127.0.0.1/up']
            interval: 30s
            timeout: 5s
            retries: 5
            start_period: 90s

Both the database and Redis are declared as dependencies that must report healthy before the app starts, and the health check itself is a request to the framework's own status endpoint every thirty seconds with a ninety-second grace period, which is the shape you expect when the first boot has migrations and seeds to run. A Postgres sixteen Alpine image holds the data in a named volume, and a shell script from the docker directory is mounted read-only into the database's initialisation directory under a name that sorts first, which is how the test database gets created on first boot. Then there is the comment that explains the two explicit database environment values: the testing environment file pins the host to localhost and the user to root, so without overrides the test suite would try to reach the host instead of the container's services.

OAuth keys go in the environment because a load balancer has more than one node

API tokens and the MCP server both ride on Laravel Passport, and the environment file makes a decision here that quietly determines whether your deployment works.

code
# Passport OAuth keys (API tokens / MCP). Prefer env vars over key files so
# every node behind a load balancer shares the same key pair. Use literal \n
# for newlines in the PEM. When unset, Passport falls back to storage/oauth-*.key
# (generate with: php artisan passport:keys).
# PASSPORT_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----"
# PASSPORT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"

The comment prefers the environment variables over key files, and the reason is given in one line: every node behind a load balancer has to share the same key pair. Key files on local disk do not travel, so a token minted on one node is signed by a key the other node does not have, and the failure appears as an intermittent authentication error that follows traffic rather than following a request. The file also tells you how to encode it, using literal newline escapes inside the quoted PEM, and what happens when you leave both variables unset, which is a fallback to key files in storage that you generate with a single artisan command. That fallback is the right default for a laptop and the wrong one for anything with more than one process. This is the second block in the same file that documents an operational consequence rather than a setting, and it is a fair signal about the file as a whole: the configuration is where this project explains itself.

The copilot re-reads the brand profile on every call

The AI side is four features that share one mechanism. The brand profile holds tone, voice, language and colours, and it is applied to every AI call rather than being folded into a one-off prompt, which is why a workspace-level setting changes output across every network at once. On top of that the copilot produces captions, hooks, full drafts and multi-slide carousels with images, and there is an inline review step before anything is published, so the draft is an object you can argue with rather than a button that posts. The carousel builder prompts its way to a multi-slide set that stays on brand, which is the feature most likely to matter to an agency since carousels are where the per-network formatting work usually lives. The repurpose feature does something different and is easy to miss: it replicates videos you post outside the tool onto your other networks, so the tool does not need to have been the origin of the content to be useful. Supporting pieces are a workspace asset library with built-in search of two public stock sources, and reusable signature and label blocks for hashtags and calls to action, colour-coded as post tags. What the documentation here does not say is which model serves the copilot or whether that choice can be pointed somewhere else.

Workspaces and roles are what separate an agency tool from a personal calendar

Two features decide whether this is for one person or for a roster. Workspaces isolate each brand, client or project in its own space, so assets, signatures, connected accounts and analytics do not bleed across a client list. On top of that sit three roles, owner, admin and member, plus comments with mentions on drafts, and the feature list describes approval flows for the cases where something has to be signed off before it goes out. That combination is the difference between a calendar you use and a calendar a team uses, and it is also where the self-hosting argument is strongest, because a workspace boundary on your own database is not a workspace boundary you have to trust a vendor to enforce. The second differentiator is the interface for machines. There is a full REST API and a first-class MCP server, and the claim is that Claude, Cursor, ChatGPT or your own scripts can draft, schedule and publish rather than just read. The interface ships in sixteen languages, which matters more than it sounds for an agency whose clients are not all in one language. And the licence has a clause worth reading before you plan around any of it: run a modified version as a network service and section 13 of the AGPL asks you to make your changes available to the users of that service.

Six npm scripts, no test script, and four agent config directories

The frontend package is small and tells you where the project has been.

code
    "scripts": {
        "build": "vite build",
        "build:ssr": "vite build && vite build --ssr",
        "dev": "vite",
        "format": "prettier --write resources/",
        "format:check": "prettier --check resources/",
        "lint": "eslint . --fix"
    },

There is a plain build, a build that also produces a server-side bundle, a dev server, a formatter that only touches the resources directory, and a lint script that fixes as it runs. There is no test script, even though a browser automation library sits in the development dependencies and a PHP test configuration file sits at the top level, so both test suites exist and are driven from outside the npm scripts. That is a reasonable arrangement in a Laravel project and it is also the arrangement where a new contributor has to ask where the tests are. The other thing in that list is a set of four agent-facing directories at the top level, alongside instruction files for several assistants and a model context configuration file. That is what a repository looks like after a few tools have been pointed at it, and it is a fair proxy for the project's current centre of gravity. The frontend itself is Vue through Inertia with Tailwind, websockets through the Laravel Echo client, and a product analytics client in the dependency list; the documentation available here does not explain how to turn that analytics client off in a self-hosted install.

Editorial conclusion

TryPost fits an agency or a technical solo operator who wants one calendar across many accounts, wants the copilot to write in a brand voice rather than a generic one, and would rather own the server than rent a seat. It does not fit someone who needs a single network done perfectly, because twelve integrations is twelve sets of platform-specific failure modes and the project does not document which of them are thin. Two obligations come with the licence. AGPL section 13 means a modified version run as a network service has to offer its changes to its users, which is the right rule and a real constraint if you were planning to run a private fork for clients. Before you commit, read the environment file rather than the feature list, because that is where the behaviour lives: the webhook base URL decides whether inbound callbacks reach you at all, the link-defusing switch changes what X bills you, and the OAuth key variables decide whether tokens survive more than one node.

Frequently asked questions

Which social networks does TryPost publish to natively?

Twelve, each through that platform's own official API: Instagram, Facebook, LinkedIn, X, TikTok, YouTube, Pinterest, Threads, Bluesky, Mastodon, Telegram and Discord. The point of native publishing is that a post does not need a handoff to a mobile app to finish.

Can an AI assistant post through TryPost?

Yes. There is a first-class MCP server alongside the REST API, and the project names Claude, Cursor, ChatGPT and your own scripts as clients that can draft, schedule and publish. API tokens for that access are issued through Laravel Passport.

What does the brand profile do in TryPost?

It stores tone, voice, language and colours, and it is applied to every AI call rather than once. That covers captions, hooks, full drafts and the multi-slide carousel builder, so a workspace-level change reaches every network.

What is X_DEFUSE_LINKS for in TryPost?

When enabled it rewrites the links in the X version of a post so they are not clickable, which keeps X from billing the post at its link-post rate. It defaults to false because a self-hosted install publishes through its own X app and pays its own bill.

Do I need a public URL to run TryPost locally?

You need one for the networks that answer by calling back. The webhook base URL variable defaults to the application URL and is meant to be set to a tunnel address during local development, because the default localhost address is not reachable by an external service.

What are the licence terms for running a modified TryPost?

The project is AGPL-3.0, so you may use, modify, fork, self-host and redistribute it including commercially. If you run a modified version as a network service, section 13 asks you to make your changes available to the users of that service.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. trypostit/trypost on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/trypostit-trypost.svg)](https://hysenlabs.com/projects/trypostit-trypost)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/trypostit-trypost.svg)](https://hysenlabs.com/projects/trypostit-trypost)

Was this useful?