OpenClaw Telegram and WhatsApp startup stall guide

Problem statement: your OpenClaw gateway says it is ready, health checks look normal, and the log even says it is starting channels, but Telegram and WhatsApp still do not come online. Then, many minutes later, the health monitor decides those accounts are stopped and starts restarting them. If that sounds familiar, you are not dealing with a normal token mistake. You are looking at a startup handoff problem where the gateway looks healthy before the channel providers are actually in a usable state.

What this specific stall looks like

The fresh April 26 report behind this guide described a Docker-based gateway upgraded from 2026.4.20 to 2026.4.24. Telegram and WhatsApp did not start promptly after readiness. The gateway logged that it was ready and starting channels, but the first provider startup logs did not appear until roughly nineteen minutes later. By then, the health monitor had already decided the accounts were stopped and attempted a restart.

That timing matters. A normal bad token problem fails closer to the provider startup moment. This pattern is different: OpenClaw spends a long time in a state that looks alive from the outside, while the actual provider handoff remains stuck or delayed inside the runtime.

Evidence from the field

• GitHub issue #72065 was opened on 2026-04-26 with a reproducible boot timeline where Telegram and WhatsApp provider startup lagged far behind gateway readiness.
• The report showed the gateway reaching readiness, logging starting channels and sidecars, and then remaining quiet for about nineteen minutes before any Telegram or WhatsApp provider startup lines appeared.
• Runtime dependencies were prepared under both a versioned root and an unexpected openclaw-unknown-* root, which is a strong clue that one startup path was resolving package identity inconsistently.
• Network checks to https://api.telegram.org and the WhatsApp WebSocket endpoint succeeded, which rules out the simplest “the container cannot reach the internet” explanation.

The root cause in plain language

This startup stall is best understood as a runtime-dependency and provider-handoff problem, not a messaging-platform outage. The reported evidence suggests that one part of the channel runtime-deps flow resolved a package boundary with an unknown version, which created an extra openclaw-unknown-* dependency root next to the expected versioned root. When startup depends on that runtime material being consistent, provider initialization can drift into a delayed or half-stuck state.

You do not need to prove the internal implementation detail perfectly before acting. The practical lesson is simpler: if the gateway is ready but providers do not start for many minutes, and the runtime-deps cache is split across two roots, treat the dependency boundary as unstable. That is the branch of the tree worth debugging first.

How to tell this apart from a normal channel outage

Symptom	Most likely branch
Gateway ready, then long silence before any provider startup log	Runtime-deps or startup handoff problem
Immediate invalid token or auth error after provider startup	Credential problem
Container cannot reach Telegram API or WhatsApp WebSocket at all	Network or firewall problem
Channels start normally, then later disconnect under load	Operational instability after startup, not this guide

Fast diagnostic workflow

1) Capture one clean boot timeline

Resist the urge to restart repeatedly. Save one full startup sequence from the first line where runtime dependencies are prepared through the point where the gateway becomes ready, then continue until either provider startup logs appear or the health monitor begins restart attempts. You need the timeline, not just the final error.

2) Mark the exact delay between readiness and provider startup

In the fresh report, the gap was about nineteen minutes. Your environment may differ, but a long readiness-to-provider gap is the signal. If your first Telegram or WhatsApp provider line arrives far later than expected, write that down. It helps separate this issue from immediate auth failures.

3) Inspect the runtime-deps roots

Look under ~/.openclaw/plugin-runtime-deps/ and check whether channel dependencies were prepared under both a normal versioned root and an unexpected unknown root. A split like that is one of the strongest clues that your startup path is not resolving package state consistently.

ls ~/.openclaw/plugin-runtime-deps/
find ~/.openclaw/plugin-runtime-deps -maxdepth 2 -type d | sort
find ~/.openclaw/plugin-runtime-deps -path '*telegram*' -o -path '*whatsapp*' | sed -n '1,40p'

4) Prove or disprove simple egress failure

Do not assume the network is guilty just because messaging channels are involved. The April 26 report included successful calls to the Telegram API and a successful WebSocket open to WhatsApp. If those simple checks work in your environment too, stop spending time on generic egress debugging.

wget -q -O- --timeout=10 https://api.telegram.org
node -e "fetch('https://api.telegram.org/botINVALID/getMe').then(async r=>console.log(r.status, await r.text())).catch(e=>console.error(e.name, e.message))"
node -e "const WebSocket=require('ws'); const t=setTimeout(()=>{console.log('TIMEOUT');process.exit(2)},15000); const ws=new WebSocket('wss://web.whatsapp.com/ws/chat'); ws.on('open',()=>{console.log('OPEN'); clearTimeout(t); ws.close(); process.exit(0)}); ws.on('error',e=>{console.error('ERROR', e.message); clearTimeout(t); process.exit(1)})"

5) Check whether health-monitor restarts are late symptoms

If the health monitor starts restarting accounts only after a long period of silence, do not assume it created the problem. In this pattern, the providers were already failing to reach a normal startup state. The monitor is only noticing that fact later.

Step-by-step recovery plan

1) Preserve the current logs and runtime-deps directory names

Before deleting anything, record the directory names and the relevant boot logs. If you later need to compare a repaired run against the broken one, that evidence saves time.

2) Remove the broken cache deliberately, not repeatedly

If you confirmed a split runtime-deps root, remove the affected cached runtime-deps directories once, then trigger a clean rebuild. The goal is to test whether the duplicated root reappears. If it does, you are dealing with a repeatable dependency-boundary problem and not just one dirty cache.

3) Restart and watch for the first provider startup line

Do not stop at the gateway-ready line. Continue watching until you see the first Telegram or WhatsApp provider startup line. A healthy repair is not “the gateway is back”; it is “the providers reached startup promptly.”

4) Verify one real send path after startup

A UI that looks alive is not enough. Trigger one real channel action, such as a simple Telegram or WhatsApp response path, and verify that the account does not immediately fall back into stopped or restart status.

5) If the issue returns after upgrade, separate continuity from local debugging

Once a channel stack becomes part of real work, the cost of repeated startup archaeology goes up fast. If you need the bots online more than you need to keep repairing the same local path, it is worth comparing a steadier operating model before the next maintenance window surprises you again.

Fix once. Stop recurring Telegram and WhatsApp startup stalls.

If this keeps coming back, you can move your existing setup to managed OpenClaw cloud hosting instead of rebuilding the same stack. Import your current instance, keep your context, and move onto a runtime with lower ops overhead.

• Import flow in ~1 minute
• Keep your current instance context
• Run with managed security and reliability defaults

If you would rather compare options first, review OpenClaw cloud hosting or see the best OpenClaw hosting options before deciding.

Import your current OpenClaw instance in 1 click See OpenClaw cloud hosting

Edge cases that can fool you

The gateway is healthy, so you assume the startup path is finished

This is the biggest trap. Readiness can arrive before channel providers are truly online. For channel operators, a useful startup is provider startup, not only HTTP health.

You clear the cache and the problem appears fixed once

One successful restart is not enough. If the unknown root returns on the next rebuild or next upgrade, you have only delayed the incident. Check the directory structure after the repair, not just the first successful boot.

Telegram starts before WhatsApp, or vice versa

That does not disprove the shared runtime issue. The important clue is that both channels depend on the same broader startup machinery. A partial recovery can still point to the same underlying dependency drift.

The health monitor seems to fix it eventually

Even if the monitor eventually wakes the channels up, that is still an unhealthy boot path. A nineteen-minute delay after readiness is already too expensive for most production workflows.

How to verify the fix

• The gap between gateway readiness and provider startup is gone or dramatically reduced.
• Telegram and WhatsApp provider logs appear promptly after the gateway says it is starting channels.
• The runtime-deps cache no longer splits across both a normal versioned root and an unexpected unknown root.
• One real send or response workflow succeeds.
• A second restart does not recreate the stall.

Typical mistakes

• Stopping the investigation at “the gateway is ready.”
• Debugging tokens first even though provider startup never really begins.
• Restarting over and over without preserving one clean boot timeline.
• Assuming health-monitor restarts are the root cause instead of the downstream symptom.
• Ignoring the runtime-deps directory split because the names look like harmless cache noise.

FAQ

Can this happen even when the gateway says channels are starting?

Yes. That is exactly what makes this issue confusing. The visible startup banner can appear before the providers actually come online.

Should I rotate Telegram or WhatsApp credentials first?

Not first. Credential work makes more sense after you confirm provider startup is happening normally. In this failure pattern, startup itself is the broken step.

Does a successful network probe prove the channels should work?

No. It only proves you are probably not dealing with the simplest egress failure. You still need a healthy runtime-deps path and prompt provider handoff.

What should I read next?

Review OpenClaw cloud hosting if reliability is now the main concern, visit /compare/ if you are weighing self-hosted against managed options, and use OpenClaw Setup if you want a steadier path without rebuilding everything by hand.