Trello is the de facto kanban tool for small and mid-size teams. It is fast, simple, and almost every product, marketing, or ops team has at least one board running. The problem is the same as with any tool that humans run by hand: as the volume grows, manual handling stops scaling. Updates get missed, cards stay in "Doing" for weeks, retrospectives turn into archaeology.

The fastest way to fix that is to give an AI agent live access to Trello through the official JSON API. In this article, we will walk through the full setup: how to get an API key, how to generate a token, how to wire both into OpenClaw, what the JSON API can and cannot do, and what to be careful about. By the end you will have a real, working agent that can read, create, move, and update cards, lists, and boards on your behalf.

This is the third article in the "How to connect X to OpenClaw" series. If you have already read How to automate Gmail with OpenClaw and How to automate Telegram with OpenClaw, you will notice the pattern: same shape, simpler auth. Trello sits between the two — no Google Cloud project, no OAuth Consent Screen, but you do need a key and a token (not a single bot token like Telegram).

What is Trello and what can the API do?

Trello is built on three primitives:

• Boards. A board represents a project, a workflow, or a workspace. Each board has members and lists.
• Lists. A list is a column on a board — "Backlog", "In progress", "Done".
• Cards. A card is a unit of work inside a list. Cards have descriptions, due dates, labels, checklists, attachments, comments, and members.

On top of these, Trello has members, labels, checklists, attachments, power-ups, and custom fields. The JSON API exposes all of them.

What the API can do for you:

• read every board, list, and card the token has access to;
• create, update, move, archive, and delete boards, lists, and cards;
• add and remove members and labels;
• post comments and checklists;
• set due dates, attachments, and custom field values;
• subscribe to webhooks for real-time updates.

What the API cannot do, or can do with limits:

• it cannot impersonate other members (you act as the user the token belongs to);
• rate limits apply (100 requests per 10 seconds per token, 300 requests per 10 seconds per API key — more on this below);
• some advanced features (Power-Ups, certain custom fields) require paid Trello plans.

Why Trello's JSON API is the right integration path

There are three ways to integrate third-party software with Trello.

1. Power-Ups. Trello's own extension system. Power-Ups are iframe apps that live inside Trello. They are good for UI-heavy extensions but bad for backend automation — they require Trello to host your app's UI and they cannot run on a schedule without the user being online.

2. The unofficial "scraping" path. Some tools log in as a Trello user and click around with a headless browser. This works, but it is fragile, slow, and against Trello's terms of service.

3. The official JSON API. This is the path we take in this article. It is documented, supported, scoped, and works for everything we need. Trello explicitly recommends it for backend automation.

In this article we use path 3.

The full flow for connecting Trello to OpenClaw

The path is:

• Create or sign in to your Trello account.
• Open the API key page and copy the key.
• Generate a token with the scopes your agent needs.
• Save the key and the token in a safe place.
• Pass both to OpenClaw.
• Start OpenClaw and verify with a simple request.
• Optional: configure a webhook for real-time updates.

Step 1. Create or sign in to a Trello account

If you do not yet have a Trello account, sign up at trello.com. For a production agent, we recommend creating a dedicated service account — a separate Trello user that owns the agent's boards and acts on the agent's behalf. This way:

• the agent's actions are easy to audit (one user);
• revoking access is one click;
• the agent's boards do not clutter your personal Trello.

A service account is a normal Trello account with a normal email. Trello does not have a separate "service account" concept, but a dedicated user is the right pattern.

Step 2. Get the API key

Sign in to the Trello account the agent will use, then go to:

https://trello.com/app-key
          

You will see two important values:

• API key. A long alphanumeric string. This identifies the application (or in our case, the agent).
• Token generation link. A button labeled "Token" or a link to generate a token.

The API key is essentially the application's identifier. Anyone who has both the key and the token can act on the Trello account, so treat the key like a public-but-not-public identifier. The token is the actual secret.

You can also set an app name and a callback URL for OAuth-based integrations. For OpenClaw, we do not need OAuth — the manual token flow is simpler and works just as well for a single-tenant agent.

Step 3. Generate a token

On the same page (https://trello.com/app-key), click the token link. Trello will show a consent screen listing the scopes the token will have. The most common scopes are:

• read — read boards, lists, cards, members.
• write — create, update, move, archive cards, lists, boards.
• account — read the account profile. Usually not needed for an agent.

For a typical agent, read + write is enough. Do not grant scopes you do not need — this is the principle of least privilege.

Click Allow. Trello will show the token. Copy it. You will not be able to see it again — if you lose it, you have to revoke and generate a new one.

The token looks like a long alphanumeric string. It is valid until you revoke it. There is no automatic expiry for manually generated tokens.

If you want to revoke the token later, go to:

https://trello.com/<your-username>/account
          

then to the Apps section, find the token, and click Revoke.

Step 4. Save the key and the token

The API key and the token are both secrets. Save them somewhere protected. Recommended pattern:

# API key
          echo -n "your_api_key_here" > ~/.config/openclaw/secrets/trello-api-key
          chmod 600 ~/.config/openclaw/secrets/trello-api-key

          # Token
          echo -n "your_token_here" > ~/.config/openclaw/secrets/trello-token
          chmod 600 ~/.config/openclaw/secrets/trello-token
          

Or as environment variables:

export TRELLO_API_KEY=your_api_key_here
          export TRELLO_TOKEN=your_token_here
          

Important:

• Do not commit either value to git.
• Do not paste them into Slack, Telegram, or any chat.
• Do not write them to public logs.
• If either leaks, revoke the token immediately and generate a new one. The old token stops working within seconds.

Step 5. Pass the key and token to OpenClaw

In the OpenClaw service configuration (systemd, supervisor, Docker, or a launch script), add both:

TRELLO_API_KEY=your_api_key_here
          TRELLO_TOKEN=your_token_here
          

If you prefer the secrets-file path, OpenClaw also reads from ~/.config/openclaw/secrets/trello-api-key and ~/.config/openclaw/secrets/trello-token when the Trello channel is configured to use files.

In the OpenClaw UI, go to Settings → Channels → Trello → Add channel and paste both values through the interface. The UI stores them encrypted.

After both are saved, OpenClaw automatically:

• validates the key and token by calling GET /members/me;
• resolves the Trello member the token belongs to;
• registers the available boards in the agent's tool registry;
• sets up the JSON API client with the right base URL (https://api.trello.com/1/) and the right auth method.

Step 6. Verify the connection

Open a chat with the agent (Telegram, OpenClaw UI, or CLI) and run a small check. For example:

trello.list_boards
          

A successful response lists the boards the token can see:

[
          { "id": "5d8...e1a", "name": "Marketing Q3", "url": "https://trello.com/b/..." },
          { "id": "9f3...c2b", "name": "Product Roadmap", "url": "https://trello.com/b/..." }
          ]
          

If the response is an empty list, the token has no boards. Add the service account to a board in Trello, and the next call will see it.

If the response is an error, the most common causes are:

• 401 Unauthorized — the key or token is wrong, or the token has been revoked. Re-check with https://trello.com/app-key.
• 403 Forbidden — the token does not have the right scopes. Re-generate with read + write.
• 429 Too Many Requests — the rate limit was hit. Wait 10 seconds and retry. For high-volume agents, batch requests and use webhooks instead of polling.

A useful manual check that does not involve OpenClaw — a direct call to the Trello API:

curl "https://api.trello.com/1/members/me?key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
          

If the response is JSON with a fullName and an id, the key and token are both valid.

Step 7 (optional). Configure a webhook for real-time updates

By default, OpenClaw reads Trello on demand. This is fine for many use cases but means the agent only knows about changes when it next asks. For real-time workflows, Trello supports webhooks: Trello itself POSTs to a URL you specify whenever a card, list, or board changes.

To set up a webhook:

• expose a public HTTPS endpoint that OpenClaw can listen on (Let's Encrypt is enough);
• in the OpenClaw UI, go to the Trello channel and set the webhook callback URL;
• OpenClaw registers the webhook with Trello by calling POST /webhooks with the board ID, the callback URL, and a description.

After registration, Trello sends a POST to your endpoint with a JSON payload describing the change. OpenClaw parses it, runs the agent's reasoning loop on the new event, and the agent can react in real time.

Common webhook use cases:

• when a card moves to "Done", post a Slack message and update a CRM;
• when a card is added to "In progress" by anyone, ping the assignee in Telegram;
• when a card is labeled "bug", open a draft issue in GitHub;
• when a card's due date is missed, send a reminder to the owner.

Webhooks are the difference between an agent that polls and an agent that reacts.

Rate limits and how to handle them

Trello's limits, as of 2026:

• 100 requests per 10 seconds per token.
• 300 requests per 10 seconds per API key.
• No daily cap, but abusive patterns can trigger a temporary ban.

Practical patterns:

• Batch reads. When listing cards on a board, prefer GET /boards/{id}/cards?fields=... over per-card fetches.
• Use fields to shrink responses. Default responses include every field; ?fields=id,name,desc,due,idList cuts payload size by 5–10×.
• Cache. The agent does not need to refetch board structure on every turn. Cache the board ID, list IDs, and label IDs in memory; refetch only on changes.
• Back off on 429. Trello includes a Retry-After header. Respect it.
• Prefer webhooks over polling. Polling burns rate limit; webhooks do not.

What you can automate after connecting

Once the agent has Trello access, the realistic scenarios are:

1. Sprint planning. The agent reads the backlog list, breaks epics into cards, assigns members, sets due dates, and posts a sprint summary to Slack. The team reviews the cards in a standup, the agent makes the agreed edits.

2. Status sync between Trello and other systems. When a Trello card moves to "Done", update the matching Linear ticket. When a GitHub PR is merged, move the matching Trello card. The agent is the single source of truth for the sync.

3. Lead capture from a landing page. A user fills a form on the website. The agent creates a Trello card in the "Sales pipeline" board, attaches the form data, assigns the sales rep, and pings the rep in Telegram. Hot leads get a fast lane; cold leads get a slower one.

4. Customer feedback collection. A support agent receives feedback in Telegram. The agent posts the feedback as a Trello card in the "Feature requests" board, with the original message quoted and the customer tagged. The product team sees all feedback in one place.

5. Recurring tasks. Every Monday morning, the agent creates the weekly ritual cards — "publish metrics", "send digest", "review support tickets", "check on-call rotation" — and assigns them based on a rotation table.

6. Code review tracking. When a PR is opened, the agent creates a Trello card linking to the PR. When the PR is merged, the card is moved to "Done". When the PR is closed without merge, the card is archived with a note.

7. Onboarding new hires. The agent creates a Trello board from a template for each new hire, with all the standard onboarding cards, assigned to the right people.

All seven scenarios share the same shape: the agent reads Trello state, makes a decision, and writes back. This is the sweet spot for Trello + OpenClaw.

The main safety rules

Trello boards are the operational truth for many teams. A bad write — a card deleted, a list renamed, a member removed — can derail a sprint. The same caution we recommended for Telegram applies here, more strictly.

Safe starting mode:

• the agent can read all boards, lists, and cards it has access to;
• the agent can create cards and comments;
• the agent can update fields it created or fields marked as safe;
• the agent does not move cards between lists without confirmation;
• the agent does not archive or delete anything without an explicit command;
• the agent does not add or remove board members;
• before any high-risk action, the agent shows a summary: which card, which list, what change, why.

Minimum safe policy for the agent:

• Do not archive or delete anything without a human confirmation.
• Do not move cards between lists in bulk without a per-card preview.
• Do not add or remove board members.
• Do not rename lists or boards.
• Do not log the API key or token, even partially.
• Log every action in an audit trail that the team can review.
• Respect rate limits: do not exceed 50 requests per 10 seconds per token.

Why manual setup is not "5 minutes"

The Trello path is genuinely simpler than Gmail and not much harder than Telegram. But "simpler" is not "5 minutes."

In practice, problems appear:

• the API key page is at a non-obvious URL (/app-key), and new users often miss it;
• the token consent screen lists scopes that are easy to misread;
• the service account is not on the board, so the token sees zero boards;
• the rate limit is hit because the agent polled every second instead of using webhooks;
• the webhook URL is http:// and Trello refuses to register it (HTTPS is required);
• the agent renames a list because the user said "fix the list name" and the agent took it literally;
• the token was pasted into a chat "to save it" and now has to be revoked;
• the OpenClaw process is running as one user but the secret file is in another user's HOME;
• the board has 5,000 cards and listing all of them blew past the rate limit;
• the custom field the agent needs is on a paid Trello plan;
• the Power-Up the team uses is not exposed by the JSON API at all;
• the agent treats the board's "Done" list as the source of truth for completion, but the team also archives "Done" cards after a week;
• the webhook delivery succeeded but OpenClaw was down for maintenance, and the agent never saw the event.

Each of these is a real situation teams hit. Most of them cost 10 to 30 minutes the first time. The cumulative cost is what an agent platform is supposed to take off your hands.

How GolemWorkers makes this easier

GolemWorkers ships Trello as a first-class channel, the same way it ships Gmail and Telegram. The setup that we walked through in this article is the underlying mechanism — but in GolemWorkers, you do not write the env files, do not store the secrets, do not wire the rate-limit governor, and do not register the webhook.

The Trello channel in GolemWorkers gives you:

• secure key + token storage in an encrypted secrets manager;
• automatic rate-limit handling with batching, backoff, and per-tenant caps;
• webhook registration and health monitoring with retries on delivery failure;
• a typed tool layer the agent can call: list_boards, list_cards, create_card, move_card, add_comment, set_due_date, and so on;
• ready-made agent templates for sprint planning, status sync, lead capture, recurring tasks, and feedback collection;
• multi-board and multi-workspace support for teams that operate across more than one Trello workspace;
• full audit trail of every Trello action the agent takes;
• safe defaults: the agent cannot archive, delete, or rename without a per-action confirmation.

If you want to see the contrast with heavier integrations, How to automate Gmail with OpenClaw shows the same shape of setup with more moving parts. How to automate Telegram with OpenClaw is the simplest of the three. And if you want the bigger picture on agents, start with AI agents: the complete practical guide.

Conclusion

Connecting OpenClaw to Trello over the JSON API is the fastest, supported, and safest way to give an AI agent real access to your kanban. Three things are worth remembering:

• the API key and the token are both secrets — store them like private API keys;
• respect the rate limit; use webhooks instead of polling for real-time work;
• the agent should not archive, delete, or rename anything without confirmation, no matter how clear the instruction seems.

If you do not want to deal with env files, secrets, rate limits, and webhooks by hand, GolemWorkers ships a Trello channel with the right defaults, the right safety rails, and a set of ready-made agent templates.

Common pitfalls

• Skipping the planning phase — Teams that jump straight into prompt engineering usually spend weeks rebuilding once they hit edge cases. Spend 30 minutes mapping the trigger, the action, and the fallback before writing the first instruction.
• Treating the first successful run as done — A 90% pass rate still produces 1 wrong answer in 10. Set an explicit acceptance threshold (typically 99% for production) and instrument the agent to log when it falls short.
• Skipping audit logging — If you can't replay what the agent did three weeks ago, you can't debug it, bill it, or trust it. Persist every tool call with timestamps and inputs from day one.
• Replacing project managers instead of augmenting them — PMs who feel replaced by the agent resist it. Frame the agent as the PM's assistant (status reports, standup drafts) and adoption goes 5x faster.

Related articles

• How to automate Vercel deployments with OpenClaw
• How to automate Asana with OpenClaw
• How to automate Slack with OpenClaw
• OpenClaw Skills vs Plugins: The Architectural Fork Beginn...
• How to run autonomous coding tasks in OpenClaw with Codex...

FAQ

What is automate trello with openclaw?

automate trello with openclaw is a workflow where an AI agent executes the recurring tasks that a human would otherwise do manually — typically with the same tools (APIs, CLIs, message apps) but in a fraction of the time. The article above walks through the full setup and shows the working end-state.

How do I what is trello and what can the api do??

Start with the prerequisites listed in the article. For most tutorials that's a GolemWorkers account, the target tool's API credentials, and ~15 minutes. The article walks through each prerequisite as it becomes relevant, so you can read top-to-bottom or jump to a specific step.

How long does it take to set up automate trello with openclaw?

The first-time setup takes 20-45 minutes including account creation, API key exchange, and a smoke-test run. Subsequent runs take under a minute because the agent persists its configuration. The exact timing is documented in each step of the article.

How much does automate trello with openclaw cost?

GolemWorkers charges per agent execution (see golemworkers.com/pricing for current rates). The target tool's own API costs are separate and usually negligible for personal/team-scale use. The article includes a 'cost section' near the end where applicable.

What are alternatives to automate trello with openclaw?

Common alternatives include Zapier (more expensive at scale, less flexible), Make (similar trade-offs), n8n (self-hosted, steeper setup), and Claude Code / Cursor (great for code-first workflows, less for ops/CRM/messaging). The article links to the relevant comparison piece where it exists in the cluster.