Set Up a Bluesky → Twitch Live Feed Bot for Your Gaming Server

Hook: Stop missing live streams — automate LIVE badges + Twitch links into Discord

If your indie esports team or streamer collective struggles to surface who’s live and when, you’re not alone. Manual shoutouts are inconsistent, pings annoy non-viewers, and bots that spam duplicate posts drive members away. In 2026, cross-platform visibility matters: Bluesky’s new LIVE badges and Twitch’s matured EventSub system let you build a clean, reliable pipeline so every community member sees live alerts where they hang out — Discord.

Why this matters in 2026 (short take)

Late 2025 and early 2026 brought a clear shift: Bluesky saw a surge in installs and shipped features that encourage stream sharing — including the ability to announce Twitch streams and a visible LIVE badge on posts. That means your members might already be sharing live links on Bluesky. Pair that with Twitch’s EventSub push notifications and Discord’s embed-rich webhooks, and you can make a dependable, low-noise live-notification system that improves retention and discoverability.

“Bluesky adds the ability to share when they’re live-streaming on Twitch and introduced LIVE badges” — Tech reporting, Jan 2026

What you’ll build (high level)

• A bot that listens for Twitch EventSub stream-start events (Twitch EventSub).
• Optional: a connector that creates or detects a Bluesky post with the new LIVE badge.
• Auto-posting to one or more Discord channels via webhooks or a bot account — with rich embeds, role pings (configurable), and dedupe logic.
• An admin UI or config file for mapping Discord members to Twitch and Bluesky handles.

Two practical approaches (choose based on resources)

1) Twitch-first (recommended)

Use Twitch EventSub to detect when a streamer goes live. Post to Discord immediately and optionally create a Bluesky post (via the AT Protocol) announcing the stream — so the streamer’s Bluesky audience and your Discord both get consistent messaging.

2) Bluesky-first

Monitor member Bluesky timelines for posts that include the LIVE badge or a Twitch link. When a qualifying post appears, announce to Discord. This is lower-cost if you prefer to honor streamers’ Bluesky-native posts and avoid posting on their behalf.

Before you start — checklist

1. Create a Twitch developer app (for EventSub and client credentials).
2. Set up a Discord webhook or bot account with the right channel permissions.
3. Decide whether your service will post to Bluesky (requires Bluesky API login/app credentials) or only monitor Bluesky posts.
4. Choose hosting: a cloud VM / container (Fly.io, Render, or DigitalOcean) or serverless with a persistent webhook endpoint (needs a public HTTPS URL for EventSub).
5. Secure storage for tokens and secrets (environment variables or secret storage).

Step 1 — Register and configure Twitch EventSub

1. Register your Twitch app at the Twitch Developer Console. Note your client ID and client secret.
2. Get an OAuth token using client credentials (or authorization code if needed for user-specific scopes).
3. Subscribe to the stream.online EventSub topic for each streamer you want to watch. EventSub supports webhook delivery to a public HTTPS endpoint and retries if your endpoint returns 5xx.
4. Verify messages using Twitch’s HMAC signature header to avoid accepting spoofed events.

Example EventSub subscription flow (pseudo):

// Use your server to call Twitch API to subscribe
POST https://api.twitch.tv/helix/eventsub/subscriptions
{ "type": "stream.online", "version": "1", "condition": { "broadcaster_user_id": "12345" }, "transport": { "method": "webhook", "callback": "https://your.example.com/twitch/webhook", "secret": "YOUR_SECRET" } }

Best practices for EventSub

• Use a single subscription per streamer (don’t create duplicates).
• Handle webhook verification and keep secrets rotated.
• Respect Twitch rate limits and use exponential backoff on errors.

Step 2 — Map Discord members to Twitch & Bluesky accounts

To prevent false matches and to enable account-specific behavior (for example, posting on Bluesky on their behalf), create a simple mapping table. Offer a secure linking flow where members authorize the connection:

• Twitch OAuth to confirm ownership of the Twitch account.
• Optional Bluesky authentication if you plan to post as the streamer.

Store only the tokens you need; mark them as encrypted-at-rest.

Suggested data model (JSON)

{
  "discordId": "987654321",
  "twitchId": "12345",
  "twitchLogin": "pro_gamer",
  "blueskyHandle": "pro_gamer.bsky.social",
  "twitchAccessToken": "xxx",
  "blueskySessionToken": "yyy"
}

Step 3 — Detecting the Bluesky LIVE badge (Bluesky-first approach)

Bluesky’s 2026 rollout includes a visible LIVE indicator when a user shares a Twitch stream. There are two common ways that will appear in the API:

• As a post facet or structured entity (preferred, easier to parse).
• As unstructured text containing a Twitch URL and a badge flag.

Use the atproto/bsky client libraries (official and community SDKs exist in 2026) to watch timelines or user posts. If Bluesky exposes a streaming/notifications endpoint, subscribe; otherwise poll timelines at reasonable intervals (respect rate limits).

Example: parse a Bluesky post for a Twitch link

// Pseudocode: fetch latest posts from a Bluesky handle and look for twitch.tv links
const posts = await bskyClient.getPostsForUser('pro_gamer.bsky.social')
for (const p of posts) {
  if (p.content.includes('twitch.tv/') || p.facets?.some(f => f.type === 'live')) {
    // found a live post
  }
}

Step 4 — Build the Discord notification payload

Decide between lightweight webhooks or a bot account for richer interactions (buttons, ephemeral messages). Webhooks are simplest: they can post embeds with thumbnails and mention roles.

Key fields to include

• Title: Streamer name + status (e.g., “LIVE: pro_gamer is streaming!”)
• Description: Game, stream title, short CTA.
• URL: Direct Twitch link.
• Thumbnail: Streamer’s Twitch profile image or channel offline image.
• Footer: Source info — “via Twitch” or “posted from Bluesky”.
• Role mention: Optional, controlled per-channel to avoid spam.

Example Discord webhook payload (JSON)

{
  "content": "<@&ROLE_ID> pro_gamer is live now!",
  "embeds": [{
    "title": "LIVE: pro_gamer is streaming Apex Legends",
    "url": "https://twitch.tv/pro_gamer",
    "description": "Join the stream — chat for lineups and scrims.",
    "thumbnail": { "url": "https://static-cdn.jtvnw.net/jtv_user_pictures/pro_gamer-profile_image.png" },
    "footer": { "text": "Live notifications via Twitch + Bluesky" }
  }]
}

Step 5 — Avoid duplicates and reduce noise

Nothing irritates members more than repeated pings. Implement:

• Debounce window: Don’t repost for a streamer for X minutes after the first notification (typical: 30–60 min).
• Change detection: Only announce on stream-start, not on every metadata update.
• Whitelist channels: Allow per-streamer channel routing and role pings opt-in.
• Duplicate prevention: Keep a short-term cache of recently-announced stream IDs.

Step 6 — Posting on Bluesky (optional)

If you want consistent cross-posts, you can use Bluesky’s write APIs (AT Protocol). This requires streamers to authorize your app to post on their behalf or to supply a session token for each streamer. Use this sparingly and only with explicit consent.

Content strategy when posting

• Keep posts short and include the Twitch link.
• Respect Bluesky norms: make the post feel native and avoid auto-generated spammy language.
• Add the LIVE badge if the API supports it; otherwise include a clear link and emoji (🔴).

Step 7 — Host, scale, and secure

Hosting options (2026)

• Fly.io or Render for containerized workers — low-latency webhooks and background jobs.
• Serverless (Cloudflare Workers or Vercel Edge functions) for verification endpoints; long-lived workers for background tasks.
• Use managed Postgres (Neon, Supabase) or Redis for dedupe cache and mapping storage.

Security & compliance

• Keep tokens in secret storage (don’t commit to git).
• Rotate Twitch and Bluesky keys periodically.
• Use HMAC verification on incoming webhooks (Twitch does this) and validate payload schema.
• Rate-limit outgoing Discord calls to avoid temporary bans.

Step 8 — Monitor, log, and iterate

Essential signals to track:

• Delivery success rates to Discord.
• Number of duplicate or suppressed notifications.
• Member reactions (views, clicks) if you can instrument link shorteners.
• Privacy complaints or opt-out requests.

Log events with context (streamer, event type, timestamp) and build a small admin dashboard for replays and troubleshooting. Consider the lessons from compact incident war rooms for fast troubleshooting at scale.

Advanced strategies for competitive communities

1) Role-based routing and timezones

Let members choose which pings they want (e.g., ‘Scrim Alerts’, ‘Casual Streams’, ‘Pro Streams’) and map streamers by timezone. Use reaction-based opt-ins: post a “subscribe” message and let members react to gain a role used for pings.

2) Show match overlays and scrim links

Include match metadata — opponent, map, and scrim lobby link — in embed fields when available. Pull this from your team’s scrim scheduler or from stream titles parsed automatically.

3) Cross-promote Bluesky posts

If a streamer posts on Bluesky with the LIVE badge, link back to the Bluesky post in your Discord embed so members can reply on Bluesky and increase cross-platform engagement.

Troubleshooting common issues

No events received from Twitch

• Check webhook callback is publicly reachable over HTTPS.
• Verify the subscription exists in Twitch console and the secret is correct.
• Check for blocked ports or cloud provider firewall rules.

Discord messages failing

• Confirm webhook URL is correct and has not been deleted.
• Check rate limits: space out retries and implement exponential backoff.
• If using a bot, ensure it has post permissions in the channel.

False positives from Bluesky parsing

• Rely on structured facets if Bluesky exposes them. If not, use regex for twitch.tv/<handle> and validate broadcaster IDs via Twitch.
• Require streamers to link accounts via your mapping flow for higher accuracy.

Quick Node.js starter (minimal)

This example shows handling a Twitch EventSub stream.online and posting to a Discord webhook. It’s intentionally minimal — production needs verification and error handling.

const express = require('express')
const fetch = require('node-fetch')
const app = express()
app.use(express.json())

app.post('/twitch/webhook', async (req, res) => {
  // Verify Twitch signature here (omitted for clarity)
  const event = req.body.event
  if (event && event.type === 'live') {
    const streamer = event.broadcaster_user_login
    const url = `https://twitch.tv/${streamer}`
    const payload = {
      content: `@here ${streamer} is live!`,
      embeds: [{ title: `LIVE: ${streamer} is now live`, url, description: event.title }]
    }
    await fetch(process.env.DISCORD_WEBHOOK_URL, { method: 'POST', body: JSON.stringify(payload), headers: { 'Content-Type': 'application/json' } })
  }
  res.status(200).send('ok')
})

app.listen(process.env.PORT || 3000)

Real-world example: How an indie esports team used this (case study)

Team Nebula (made-up but realistic) deployed a Twitch-first solution in mid-2026. Results after 60 days:

• Stream viewership rose 18% thanks to consistent Discord alerts hitting their main channels.
• Team Bluesky posts with LIVE badges increased cross-platform engagement — 5% of Discord clicks went back to Bluesky replies.
• Retention improved: members who opted into stream pings were 22% more active in the following week.

Key wins came from opt-in role pings and strict duplicate suppression.

2026 trends & future-proofing

• Cross-platform discovery: Bluesky and other federated/social platforms are becoming valuable discovery surfaces for streamers; integrating them improves reach.
• Structured metadata: Platforms are moving to structured “facets” for things like LIVE badges — build parsers that prefer structured data but fallback to text parsing.
• Privacy-first linking: Members expect clear consent flows before you post on their behalf; implement transparent scopes and easy revocation.
• Edge compute and serverless: Lower latency webhook handling via edge workers will matter for high-frequency events and fast alerts.

Final checklist before launch

1. Test EventSub delivery and Twitch signature verification.
2. Confirm mapping flow for streamer account linking works end-to-end.
3. Set debounce/dedupe window and test with multiple stream starts.
4. Set up monitoring: uptime for webhook endpoint and success metrics for Discord posts.
5. Document opt-out and moderation policy in your Discord rules channel.

Takeaways — make your community discoverable and respectful

By 2026, the best streamer communities blend platform signals (Twitch EventSub) with social posts (Bluesky LIVE badges) and a well-tuned Discord delivery system. The result is an engaged, less noisy channel where members reliably discover live events. Focus on consent, dedupe, and clear value for members and streamers alike.

Call to action

Ready to ship your Bluesky → Twitch → Discord integration? Start with the Twitch EventSub setup and a staging Discord webhook. If you want a starter repo, deploy checklist, or help mapping roles and rate limits for your server, join our community at discords.space or DM the moderators for a template build. Get your team live-aware — not spammy.

Related Reading

• Streamer Essentials: Portable Stream Decks, Night‑Vision Gear and How to Stay Live Longer
• 2026 Media Distribution Playbook: FilesDrive for Low‑Latency Timelapse & Live Shoots
• Edge Containers & Low-Latency Architectures for Cloud Testbeds — Evolution and Advanced Strategies (2026)
• Server Moderation & Safety: Practical Policies for Competitive Game Hosts (2026 Update)
• How to Host a ‘Queer Prom’ Style Long-Form Performance and Get Useful Feedback
• The Collector’s Angle: Buying and Insuring Artful Cars — From Postcard-Sized Paint Jobs to Rare Restorations
• Indexing New Maps: How to Track and Torrent Arc Raiders’ 2026 Map Drops
• Smart Cleaning Suite: Building a Sustainable, Compatible Ecosystem of Home Cleaning Devices
• From Stat Sheets to Storylines: Turning Fantasy Stats into Real-World Player Profiles