Sending Polls Across Telegram WhatsApp Discord and Teams with OpenClaw

One of the more tedious problems in multi-channel communication is doing simple things - like running a poll - across different platforms. Each messaging app has its own API, its own quirks, and its own limitations. OpenClaw's poll feature handles this by giving you one interface to send polls across Telegram, WhatsApp, Discord, and Microsoft Teams. It's the kind of thing that sounds minor until you're managing communications across multiple channels and realise how much time you're spending switching between dashboards.

Why Polls Matter for Business Communication

Before getting into the technical bits, let me explain why we care about this at all. Polls aren't just for deciding where to get lunch (though they're good for that too). In a business context, we've seen them used for:

• Quick team consensus gathering before meetings
• Customer feedback collection through existing chat channels
• Shift preference voting for rostered teams
• Approval workflows where a simple yes/no is faster than a formal process
• Event planning across distributed teams

The problem is that most organisations use multiple messaging platforms. Your internal team might be on Microsoft Teams, your customer community on Discord, your field workers on WhatsApp, and your developer community on Telegram. Running the same poll across all of them used to mean writing integrations for each platform separately.

How OpenClaw Polls Work

OpenClaw provides both a CLI and a Gateway RPC for sending polls. The CLI is straightforward - you specify the channel, the target (chat ID, phone number, or channel ID), the question, and the options. Here's what it looks like for each platform:

Telegram:

openclaw message poll --channel telegram --target 123456789 \
  --poll-question "Ship it?" --poll-option "Yes" --poll-option "No"

WhatsApp:

openclaw message poll --target +15555550123 \
  --poll-question "Lunch today?" --poll-option "Yes" --poll-option "No" --poll-option "Maybe"

Discord:

openclaw message poll --channel discord --target channel:123456789 \
  --poll-question "Snack?" --poll-option "Pizza" --poll-option "Sushi"

Microsoft Teams:

openclaw message poll --channel msteams --target conversation:19:[email protected] \
  --poll-question "Lunch?" --poll-option "Pizza" --poll-option "Sushi"

Same structure, same mental model, different platforms. That consistency is the whole point.

You can find the full OpenClaw polls documentation for all the configuration options.

The Channel Differences That Actually Matter

This is where it gets interesting, and where you'll save yourself debugging time by knowing the constraints upfront.

Telegram

Telegram is probably the most feature-rich for polls. You get 2 to 10 options, support for forum topics (useful if you're running a Telegram group with topic threads), and a duration setting in seconds (5 to 600). Telegram also lets you choose between anonymous and public polls - anonymous by default, but you can make votes visible with --poll-public.

The duration limit of 10 minutes maximum is worth noting. If you need longer polling windows, Telegram isn't the right channel for that specific poll.

WhatsApp

WhatsApp gives you the most options per poll - up to 12. It also supports maxSelections to control how many options a respondent can pick. But it completely ignores duration settings. Once a WhatsApp poll is sent, it stays open indefinitely. There's no built-in expiry.

For business use, this means you need a process around closing polls manually or simply announcing when voting is closed. Not ideal, but that's a WhatsApp platform limitation, not an OpenClaw one.

Discord

Discord polls support 2 to 10 options with duration clamped between 1 and 768 hours (default 24 hours). One quirk: Discord doesn't support "pick exactly N options." You either get single-select or multi-select, nothing in between. If you set --poll-multi, voters can pick as many options as they want.

The 768-hour maximum (32 days) is generous enough for most business scenarios. We've used this for month-long feedback collection in developer communities.

Microsoft Teams

Here's where it gets a bit different. Teams doesn't have a native poll API the way the other platforms do. OpenClaw works around this by rendering polls as Adaptive Cards. The practical implication is that the OpenClaw gateway needs to stay online to record votes - they're stored locally in ~/.openclaw/msteams-polls.json.

This means Teams polls are less "set and forget" than the other channels. If the gateway goes down, you lose the ability to collect votes until it's back up. For production use, you'll want to make sure your OpenClaw gateway has proper uptime monitoring.

Duration settings are also ignored on Teams, similar to WhatsApp.

Using Polls with AI Agents

This is where it gets really practical for agentic automation workflows. OpenClaw exposes polls through its agent tool interface using the message tool with action: "poll". Your AI agent can programmatically send polls, collect responses, and act on the results.

Think about scenarios like:

• An operations agent that polls the on-call team about incident severity before escalating
• A scheduling agent that asks team members about their availability through their preferred messaging channel
• A feedback agent that runs satisfaction polls after customer interactions

The agent tool accepts to, pollQuestion, pollOption, and optional parameters like pollMulti, pollDurationHours, and channel. For Telegram, you also get pollDurationSeconds, pollAnonymous, and pollPublic.

One important detail: you must use action: "poll" specifically. If you try to pass poll fields with action: "send", it'll be rejected. Clean separation between regular messages and polls.

Practical Tips From Our Experience

We've been building AI agent solutions that use multi-channel messaging, and here are a few things we've learned:

Start with one channel, then expand. Don't try to set up all four channels on day one. Pick the one your team or customers actually use most, get that working smoothly, then add others. The cross-channel consistency in OpenClaw means adding a new channel later is straightforward.

Be aware of the option count differences. If you're sending the same poll across multiple channels, keep it to 10 options or fewer (Telegram and Discord's limit). Better yet, keep it to 4-5 options. Nobody wants to read through 12 choices on their phone.

Test the Teams Adaptive Card approach separately. Because it works differently from the native poll implementations on other platforms, Teams polls deserve their own testing. Make sure your gateway stays up and that vote recording works as expected.

Use idempotency keys in the Gateway RPC. If you're calling the gateway programmatically, always include an idempotency key. Network retries can happen, and you don't want duplicate polls confusing your audience.

When to Use This vs. Dedicated Survey Tools

OpenClaw polls are great for quick, lightweight polling within existing conversations. They're not a replacement for proper survey tools like Typeform or SurveyMonkey when you need:

• Complex branching logic
• Detailed analytics and reporting
• Compliance-grade data collection
• Anonymous responses across all channels (only Telegram supports this natively)

Use OpenClaw polls for the quick-hit questions that don't warrant sending people to a separate survey link. "Should we deploy today?" "Which option do you prefer?" "Are you available Thursday?" That's where they shine.

Getting Started

If you're building multi-channel communication into your business workflows, polls are just one piece of the puzzle. We help organisations set up AI-powered automation that includes messaging, polling, and decision-making across channels. Reach out via our contact page if you want to talk through what a multi-channel approach might look like for your team.

The barrier to getting started is low - OpenClaw's CLI means you can test polls from your terminal in minutes. The real work is figuring out which workflows benefit from cross-channel polling and designing the agent logic around the responses.