How to Automate Slack Project Updates using the API

Understanding the Slack API

Setting Up Slack API Authentication

Bot tokens (xoxb-) are workspace-scoped and long-lived. For project updates, the bot needs chat:write to post messages, and optionally chat:update if you'll edit messages. Invite the bot to each project channel. Token rotation is opt-in — without it, tokens don't expire.

1. 1Go to https://api.slack.com/apps and click Create New App > From scratch.
2. 2Click OAuth & Permissions. Add Bot Token Scopes: chat:write, chat:write.public (optional, allows posting to public channels without joining).
3. 3Click Install to Workspace and authorize.
4. 4Copy the Bot User OAuth Token (xoxb-).
5. 5Invite the bot to your project channels: /invite @YourBotName.
6. 6Optionally set up Event Subscriptions (incoming webhooks from GitHub/Jira) or a Route Handler endpoint to receive external webhooks.
7. 7Store SLACK_BOT_TOKEN in environment variables.
8. 8Store channel IDs as environment variables (not names) — channel IDs never change, names can.

1import os
2import requests
3
4BOT_TOKEN = os.environ["SLACK_BOT_TOKEN"]
5HEADERS = {"Authorization": f"Bearer {BOT_TOKEN}"}
6
7# Verify token
8resp = requests.post("https://slack.com/api/auth.test", headers=HEADERS)
9data = resp.json()
10if data.get("ok"):
11    print(f"Authenticated as bot in: {data['team']}")

Key endpoints

1{"channel":"C01234567","text":"Build succeeded: v2.1.4","blocks":[{"type":"section","text":{"type":"mrkdwn","text":"*Build succeeded* :white_check_mark: `main` branch\n>Version: v2.1.4\n>Triggered by: @john"}},{"type":"context","elements":[{"type":"mrkdwn","text":"Duration: 3m 42s | <https://ci.example.com/build/123|View build>"}]}]}

1{"ok":true,"channel":"C01234567","ts":"1746612000.000100","message":{"type":"message","text":"Build succeeded: v2.1.4"}}

1{"channel":"C01234567","ts":"1746612000.000100","text":"Deploy complete","blocks":[{"type":"section","text":{"type":"mrkdwn","text":"*Deploy complete* :white_check_mark: v2.1.4 to production"}}]}

1{"ok":true,"channel":"C01234567","ts":"1746612000.000100","text":"Deploy complete"}

1{"channel":"C01234567","text":"Sprint 12 ends today — retrospective at 4pm!","post_at":1746957600}

1{"ok":true,"scheduled_message_id":"Q01234567890","post_at":1746957600,"channel":"C01234567"}

Step-by-step automation

1# Test your webhook endpoint with a GitHub-style payload
2curl -X POST \
3  -H "Content-Type: application/json" \
4  -H "X-GitHub-Event: push" \
5  -H "X-Hub-Signature-256: sha256=$(echo -n '{"ref":"refs/heads/main"}' | openssl dgst -sha256 -hmac 'your_secret' | cut -d' ' -f2)" \
6  -d '{"ref":"refs/heads/main","head_commit":{"message":"Fix: login bug","author":{"name":"John"}},"repository":{"name":"myapp"}}' \
7  "https://yourapp.com/webhook/github"

1curl -X POST \
2  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "channel": "C01234567",
6    "text": "Push to main: Fix login bug",
7    "blocks": [
8      {"type":"section","text":{"type":"mrkdwn","text":"*Push to `main`* :arrow_up_small:\n>Fix login bug\n>by @john — <https://github.com/org/repo/commit/abc123|View commit>"}},
9      {"type":"context","elements":[{"type":"mrkdwn","text":"myapp | May 7, 2026 10:15 AM"}]}
10    ]
11  }' \
12  "https://slack.com/api/chat.postMessage"

1# Post and capture the ts
2curl -s -X POST \
3  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
4  -H "Content-Type: application/json" \
5  -d '{"channel":"C01234567","text":"Build started","blocks":[{"type":"section","text":{"type":"mrkdwn","text":"*Build started* :hourglass_flowing_sand: v2.1.4"}}]}' \
6  "https://slack.com/api/chat.postMessage" \
7  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('ts',''))"

1# Schedule a message for tomorrow 9am UTC
2POST_AT=$(date -d 'tomorrow 09:00:00' +%s)
3curl -X POST \
4  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
5  -H "Content-Type: application/json" \
6  -d "{\"channel\":\"C01234567\",\"text\":\"Sprint 12 ends today — retro at 4pm!\",\"post_at\":$POST_AT}" \
7  "https://slack.com/api/chat.scheduleMessage"

Complete working code

A complete GitHub webhook handler that receives push and deploy events, formats Block Kit messages, posts to the project Slack channel with live status updates (posting initial message then updating it when the build completes), and includes rate-limit-aware retry logic.

1import os, time, hmac, hashlib, logging, requests
2from flask import Flask, request, jsonify
3
4logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
5
6BOT_TOKEN = os.environ["SLACK_BOT_TOKEN"]
7GITHUB_SECRET = os.environ["GITHUB_WEBHOOK_SECRET"]
8PROJECT_CHANNEL = os.environ["SLACK_PROJECT_CHANNEL_ID"]
9H = {"Authorization": f"Bearer {BOT_TOKEN}"}
10
11# Store active build messages: {build_id: {channel, ts}}
12build_messages = {}
13
14flask_app = Flask(__name__)
15
16def post_slack(channel, text, blocks=None, thread_ts=None):
17    for _ in range(5):
18        payload = {"channel": channel, "text": text}
19        if blocks: payload["blocks"] = blocks
20        if thread_ts: payload["thread_ts"] = thread_ts
21        resp = requests.post("https://slack.com/api/chat.postMessage", headers=H, json=payload)
22        if resp.status_code == 429:
23            time.sleep(int(resp.headers.get("Retry-After", 2)) + 0.5)
24            continue
25        data = resp.json()
26        if not data.get("ok"): raise ValueError(data.get("error"))
27        return data
28    raise RuntimeError("Max retries")
29
30def update_slack(channel, ts, text, blocks=None):
31    payload = {"channel": channel, "ts": ts, "text": text}
32    if blocks: payload["blocks"] = blocks
33    resp = requests.post("https://slack.com/api/chat.update", headers=H, json=payload)
34    return resp.json()
35
36@flask_app.route("/webhook/github", methods=["POST"])
37def github_webhook():
38    sig = request.headers.get("X-Hub-Signature-256", "")
39    expected = "sha256=" + hmac.new(GITHUB_SECRET.encode(),
40                                    request.data, hashlib.sha256).hexdigest()
41    if not hmac.compare_digest(expected, sig):
42        return jsonify({"error": "bad signature"}), 403
43
44    event = request.headers.get("X-GitHub-Event", "")
45    data = request.json
46
47    if event == "push" and data.get("ref", "").startswith("refs/heads/main"):
48        branch = data["ref"].replace("refs/heads/", "")
49        commit = data["head_commit"]
50        blocks = [{
51            "type": "section",
52            "text": {"type": "mrkdwn", "text": (
53                f"*Push to `{branch}`* :arrow_up_small:\n"
54                f">*{commit['message'][:80]}*\n"
55                f">by {commit['author']['name']} | "
56                f"<{commit['url']}|View commit>"
57            )}
58        }]
59        result = post_slack(PROJECT_CHANNEL, f"Push to {branch}: {commit['message'][:50]}",
60                            blocks=blocks)
61        logging.info(f"Posted push notification: ts={result['ts']}")
62
63    return jsonify({"ok": True})
64
65if __name__ == "__main__":
66    flask_app.run(port=3000)
67

Error handling

Rate Limits for Slack API

1import time
2
3def post_with_retry(url, headers, payload, max_retries=5):
4    import requests
5    for i in range(max_retries):
6        resp = requests.post(url, headers=headers, json=payload)
7        if resp.status_code == 429:
8            wait = int(resp.headers.get('Retry-After', 2)) + 0.5
9            time.sleep(wait)
10            continue
11        data = resp.json()
12        if not data.get('ok'):
13            if data.get('error') == 'ratelimited':
14                time.sleep(2)
15                continue
16            raise ValueError(data.get('error'))
17        return data
18    raise RuntimeError('Max retries exceeded')

• Post one message per channel per second maximum — queue rapid-fire events and process them sequentially.
• Use chat.update to edit an existing message instead of posting new messages for status transitions — reduces channel noise and respects rate limits.
• For multi-step build pipelines, post one message per build and update it with the latest status rather than posting a new message for each step.
• Store message (channel, ts) in a database keyed by your build/job ID so you can update it when the job completes via a separate webhook.
• Use thread_ts to post detailed logs as thread replies — keeps the main channel clean while preserving drill-down details.

Security checklist

Automation use cases

No-code alternatives

Don't want to write code? These platforms can automate the same workflows visually.

Best practices

• Save the (channel, ts) from every chat.postMessage response in your database keyed by job/build/ticket ID — enables status updates and threading.
• Use chat.update for in-place status changes rather than new messages — a single live-updating message is cleaner than a stream of status messages.
• Keep Block Kit text fields under 200 characters for webhook data — truncate and link to source for full details.
• Always include a plain text fallback alongside blocks — used in push notifications and accessibility.
• For high-frequency events (e.g., every commit), consider batching updates every 30 seconds rather than posting for each event.
• Validate and sanitize all external data before including in Block Kit text — long commit messages, unusual characters, and mrkdwn-like text can break formatting.
• Schedule batch reports (daily, weekly) during off-peak hours — reduces noise and respects rate limits.

Ask AI to help

Copy one of these prompts to get a personalized, working implementation.

Related automations