Use cases

Pushpush is a simple building block: send an HTTP request, get a notification on your phone. Here’s a cookbook of ways to wire it into your workflow.

AI agents & Claude Code

Know when a long task finishes

You’re kicking off a refactor, migration, or test suite that’ll take a while. Tell Claude Code to ping you when it’s done so you can context-switch to something else.

Refactor the auth module to use the new token format. Send me a push on “claude” when you’re done.

Run the full test suite and push me the results on “tests”.

Get notified when Claude hits a blocker

Claude Code can use Pushpush proactively. Add something like this to your CLAUDE.md:

If you have the Pushpush MCP server connected, use send_push
to notify me on the "claude" topic when you need my attention —
e.g. when a long task finishes, when you hit a blocker, or
when you have a question.

Now Claude will push you when it’s stuck waiting for a decision, rather than silently stalling.

Agent-to-human handoff

If you’re building agents with the Claude Agent SDK or similar, Pushpush works as a lightweight escalation channel. When the agent encounters something it can’t resolve, it pushes to a topic you’re watching.

curl -X POST https://a.pushpu.sh/agent-escalations \
  -H "Authorization: Bearer $PUSH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Agent needs approval",
    "message": "PR #142 has failing checks. Manual review required.",
    "click": "https://github.com/yourorg/repo/pull/142"
  }'

CI/CD & deploys

Deploy notifications

Add a step at the end of your deploy pipeline to push the result. You know immediately whether to keep moving or go investigate.

# At the end of your deploy script or GitHub Action
curl -X POST https://a.pushpu.sh/deploys \
  -H "Authorization: Bearer $PUSH_TOKEN" \
  -d "v2.1.0 deployed to production"

GitHub Actions workflow

A reusable step you can drop into any workflow:

- name: Notify via Pushpush
  if: always()
  run: |
    STATUS="${{ job.status }}"
    curl -sf -X POST https://a.pushpu.sh/ci \
      -H "Authorization: Bearer ${{ secrets.PUSH_TOKEN }}" \
      -H "Content-Type: application/json" \
      -d "{
        \"title\": \"${{ github.repository }} — ${STATUS}\",
        \"message\": \"${{ github.workflow }} on ${{ github.ref_name }}\",
        \"click\": \"${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\"
      }"

With if: always(), you get notified on success and failure. Drop the condition if you only want failures.

PR activity

Use a GitHub Action to push when a PR is reviewed or approved. Useful when you’re waiting on a review and don’t want to keep refreshing.

on:
  pull_request_review:
    types: [submitted]

jobs:
  notify:
    runs-on: ubuntu-latest
    steps:
      - run: |
          curl -sf -X POST https://a.pushpu.sh/prs \
            -H "Authorization: Bearer ${{ secrets.PUSH_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{
              \"title\": \"PR review: ${{ github.event.review.state }}\",
              \"message\": \"${{ github.event.pull_request.title }}\",
              \"click\": \"${{ github.event.pull_request.html_url }}\"
            }"

Claude Code in CI

Use Claude Code with Pushpush to get AI-summarized CI notifications. The CLI works on any event type — including push-triggered deploys:

- name: Notify deploy result
  if: always()
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    npx -y @anthropic-ai/claude-code \
      --allowedTools mcp__pushpush__send_push \
      --mcp-config '{"mcpServers":{"pushpush":{"type":"http","url":"https://a.pushpu.sh/mcp","headers":{"Authorization":"Bearer ${{ secrets.PUSH_TOKEN }}"}}}}' \
      -p "The deploy finished with status: ${{ job.status }}. Send a push to the deploys topic."

For pull_request or issues events, you can use Claude Code Action instead:

- name: Notify on failure
  if: failure()
  uses: anthropics/claude-code-action@main
  with:
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
    github_token: ${{ github.token }}
    prompt: |
      Summarize the CI failure and send a push notification
      to the "ci" topic with the result.
    claude_args: >-
      --allowedTools Bash,Read,Glob,Grep,mcp__pushpush__send_push
      --mcp-config '{"mcpServers":{"pushpush":{"type":"http","url":"https://a.pushpu.sh/mcp","headers":{"Authorization":"Bearer ${{ secrets.PUSH_TOKEN }}"}}}}'

Store your Pushpush API token as a repository secret. Generate one by asking Claude Code: “Get me a Push API token that doesn’t expire”.

See the MCP integration docs for more configuration patterns.

Monitoring & alerting

Simple uptime check

A cron job that pings your service and pushes when it’s down. Lightweight alternative to a full monitoring stack when you’re running a side project.

#!/bin/bash
# Run via cron: */5 * * * * /path/to/check.sh

if ! curl -sf --max-time 10 https://yourapp.com/health > /dev/null; then
  curl -X POST https://a.pushpu.sh/alerts \
    -H "Authorization: Bearer $PUSH_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "title": "yourapp.com is down",
      "message": "Health check failed",
      "priority": 5,
      "click": "https://console.cloud.google.com/run"
    }'
fi

Priority 5 makes it a time-sensitive notification that breaks through Focus modes.

Cron job failure alerts

Wrap any cron job so you hear about failures instead of discovering them days later in a log file.

#!/bin/bash
# In your crontab: 0 2 * * * /path/to/backup-wrapper.sh

if ! /path/to/backup.sh 2>&1; then
  curl -X POST https://a.pushpu.sh/alerts \
    -H "Authorization: Bearer $PUSH_TOKEN" \
    -d "Nightly backup failed"
fi

Log-based alerts

Tail a log file and push when you see something bad. Good for catching errors in apps that don’t have structured alerting.

tail -F /var/log/myapp/error.log | while read line; do
  curl -sf -X POST https://a.pushpu.sh/errors \
    -H "Authorization: Bearer $PUSH_TOKEN" \
    -d "$line"
done

Personal scripts & automation

Long-running commands

Tack a push onto the end of any command so you know when it’s done. Works for builds, data processing, large file transfers — anything where you’d otherwise keep checking back.

# After a long build
make build && curl -X POST https://a.pushpu.sh/tasks \
  -H "Authorization: Bearer $PUSH_TOKEN" \
  -d "Build finished"

# A shell function for your .zshrc
pushdone() {
  curl -sf -X POST https://a.pushpu.sh/tasks \
    -H "Authorization: Bearer $PUSH_TOKEN" \
    -d "${1:-Done}"
}

# Usage: long-command; pushdone "Migration complete"

Scheduled reminders

A cron job that sends you a push at a specific time. Low-tech but effective.

# crontab: 0 9 * * 1 curl -X POST ...
curl -X POST https://a.pushpu.sh/reminders \
  -H "Authorization: Bearer $PUSH_TOKEN" \
  -d "Weekly review time"

Web scraping & data watches

Check a page periodically and push when something changes. Useful for tracking prices, availability, or any public data.

import requests, hashlib, os

TOKEN = os.environ["PUSH_TOKEN"]
url = "https://example.com/product"
state_file = "/tmp/watch-hash"

content = requests.get(url).text
current = hashlib.sha256(content.encode()).hexdigest()

previous = open(state_file).read().strip() if os.path.exists(state_file) else ""

if current != previous:
    open(state_file, "w").write(current)
    requests.post(
        "https://a.pushpu.sh/watches",
        headers={"Authorization": f"Bearer {TOKEN}"},
        json={
            "title": "Page changed",
            "message": url,
            "click": url,
        },
    )