Changelog

Live Activities now support a new activity type: stats.

Use stats to track several values at once. It fits up to 8 labeled values, such as revenue, number of users, conversion, uptime, or any metric set you want visible at a glance.

Each item has a label and value. Add an optional color when you want a small visual cue. Leave it out when you want plain text.

1
const status = await activitysmith.liveActivities.stream("sales-hourly", {
2
  content_state: {
3
    title: "Sales",
4
    subtitle: "last hour",
5
    type: "stats",
6
    metrics: [
7
      { label: "Revenue", value: "$2430", color: "blue" },
8
      { label: "Orders", value: "37", color: "green" },
9
      { label: "Conversion", value: "4.8%", color: "magenta" },
10
      { label: "Avg Order", value: "$65.68", color: "yellow" },
11
      { label: "Refunds", value: "$84", color: "red" },
12
      { label: "New Buyers", value: "18", color: "cyan" },
13
    ],
14
  },
15
});

Call the same PUT /live-activity/stream/{stream_key} endpoint again whenever the values change. ActivitySmith keeps the Live Activity in sync on the device for you.

When the stats are no longer relevant, call DELETE /live-activity/stream/{stream_key} to end the Live Activity.

Add a dashboard button

Stats Live Activities can include the same optional action button as other Live Activity types. Use it to open the dashboard or report behind the numbers.

Set the action title to Dashboard, use open_url, and provide an HTTPS URL.

1
const status = await activitysmith.liveActivities.stream("sales-hourly", {
2
  content_state: {
3
    title: "Sales",
4
    subtitle: "last hour",
5
    type: "stats",
6
    metrics: [
7
      { label: "Revenue", value: "$2430", color: "blue" },
8
      { label: "Orders", value: "37", color: "green" },
9
      { label: "Conversion", value: "4.8%", color: "magenta" },
10
      { label: "Avg Order", value: "$65.68", color: "yellow" },
11
      { label: "Refunds", value: "$84", color: "red" },
12
      { label: "New Buyers", value: "18", color: "cyan" },
13
    ],
14
  },
15
  action: {
16
    title: "Dashboard",
17
    type: "open_url",
18
    url: "https://analytics.example.com/sales",
19
  },
20
});

Availability

Available now across the API, SDKs, and CLI.

This feature is available in the ActivitySmith iOS app version 1.8.0 and newer.

ActivitySmith lets you display any value on your Lock Screen with widgets - SaaS metrics, revenue, number of users, uptime, or anything else you want to track.

How it works

1. Create a metric in the web app.
2. Update the value using API anytime it changes.
3. Add the widget to your iPhone Lock Screen.

When creating a metric, you can choose the format: number, currency, percent, unit, or string.

Update a Metric Value from Your Backend

Call the update method with the metric key and the latest value:

1
await activitysmith.metrics.update("deploy.success_rate", 99.9);

The widget fetches the latest value about every 15 minutes. iOS manages the refresh schedule.

Widget Types

There are multiple widget types to choose from, depending on how you want the metric to appear on your Lock Screen.

Availability

Lock Screen widgets are available in the ActivitySmith iOS app version 1.7.0 and newer.

You can now track n8n workflows on your Lock Screen. Show live progress for long-running executions with Live Activities and send a Push Notification to your devices when something important happens.

How it works

Install n8n-nodes-activitysmith in n8n, add the ActivitySmith node to your workflow, and connect your ActivitySmith API key.

From there, choose what the node should do:

• Send a Push Notification.
• Start a Live Activity.
• Update an existing Live Activity.
• End a Live Activity.

Each action can use values from earlier n8n nodes. Map the workflow name, activity_id, status, result URL, or any other field you already have in the execution.

Live Activities for workflow progress

For long-running workflows, start a live activity near the beginning of the run. Update it as each stage completes, then end it when the workflow succeeds or fails.

A Live Activity can show the current step, progress, and status on the Lock Screen. It can also include an action button, so tapping the activity can open the n8n workflow URL or any other link you provide.

Push Notifications for workflow events

Use a push notification when the workflow reaches a point someone should know about immediately.

Good examples:

• A workflow execution succeeds.
• A workflow execution fails.
• A specific branch or environment finishes.
• A scheduled workflow completes.
• A step needs manual approval.
• A generated report or file is ready.

Use ActivitySmith to get Vercel deployment events on your iOS devices instead of buried in a dashboard tab. Add the generated inbound webhook URL to your Vercel project, choose the events you care about, and route them into Push Notifications and Live Activities for your team.

Start with a preset, not a blank canvas. Pick a ready-to-use preset for a deployment Live Activity, production deploy push notifications, or failed-deploy alerts and the webhook is wired up in seconds - then customize titles, actions, routing, and payload mapping however you want.

Why use this if Vercel already shows deploys in the dashboard

The Vercel dashboard is great when you are sitting in front of it. It is not great for shared visibility when a production ship is in flight and the team is in a meeting, on a walk, or heads-down in another tool.

ActivitySmith puts the same events on the lock screen and in the ActivitySmith log, with links and actions that take people straight to the right Vercel deployment.

Track production ships live. A production deploy is exactly the kind of long-running event Live Activities were built for. Start one when deployment.created fires, update it through build and promote, and close it when deployment.succeeded or deployment.error lands.

Route failures differently from the rest. Filter on target so production deployment.error and deployment.canceled page on-call, while preview deploys stay quiet on a low-priority channel.

Catch broken deploys without refreshing the dashboard. When deployment.error fires, send a push notification with the project, branch, commit, and inspector URL so whoever is closest can open the failing build in one tap.

You can use the preset as-is, or keep editing from there. Change the wording, map different payload fields (deployment URL, commit SHA, author, target), and add an action that opens the deployment in Vercel, the live URL, or an internal runbook on tap.

Use ActivitySmith to get Netlify deploy and form submission events on your iOS devices instead of buried in email. Add the generated inbound webhook URL to Netlify, choose the events you care about, and route them into Push Notifications and Live Activities for your team.

Start with a preset, not a blank canvas. There are ready-to-use presets for a deploy Live Activity, deploy status push notifications, and form submission push notifications, so you can get the first event flowing fast - then customize titles, actions, routing, and payload mapping however you want.

Why use this if Netlify already sends emails

Netlify emails the account owner on deploys and forwards form submissions to whoever is configured on the form. That works as a record. It is not great for shared visibility when something needs attention right now.

ActivitySmith puts the same events on the lock screen and in the ActivitySmith log, with links and actions that take people straight to the right Netlify page.

Track deployments live. Long-running deploys are a better fit for Live Activities than inbox threads. Start one when a deploy begins, update it as status changes, and let it disappear a few minutes after success or failure.

Route failures differently from the rest. Filter by deploy context so production deploy_failed and deploy_locked go straight to on-call while preview deploys stay quiet.

See new form submissions in seconds. When submission_created fires, send a push notification with the form name, submitter, and mapped fields so a new lead or support request shows up immediately instead of sitting in an inbox no one is watching.

You can use the preset as-is, or keep editing from there. Change the wording, map different payload fields, and add an action that opens the matching Netlify page on tap.

The ActivitySmith app icon is the one you look at every time a push notification lands on your lock screen. It should feel like yours.

You can now pick from 36 custom app icons - no ActivitySmith branding. Tap Settings → App Icon inside the app and choose the one that fits.

What's new

• 36 new alternate icons with no ActivitySmith branding.
• HTTP status code badges - 200, 2xx, 404, 503, and more.
• Label badges - CORE, FEED, SYNC, LINK, and others.
• The icon you choose replaces the default on your home screen and on the lock screen of every incoming push notification.

Heads up: an iOS bug

There's a known iOS bug where push notifications can still render the default icon on the lock screen even after you switch. Apple has acknowledged it and a fix is pending.

Until then, the workaround is simple:

1. Restart your device.
2. Open the ActivitySmith app once so the push token refreshes.

New push notifications will then show your chosen icon on the lock screen.

Availability

Available in the ActivitySmith iOS app version 1.6.0 and newer.

Use ActivitySmith to get Sentry issues, assignments, regressions, and metric alerts on your iOS devices instead of buried in inboxes or waiting inside the Sentry UI. Register the generated endpoint as a Sentry Internal Integration, subscribe to the resources you care about, and route them into push notifications for your team.

Why use this if Sentry already sends emails

Sentry emails the assignee and pings the project's notification settings. That works for individual triage. It is not great for shared response when the right people need to see the same signal fast.

ActivitySmith puts those events on the lock screen and in the ActivitySmith log, with links and actions that take people straight to the right Sentry page.

Regressions get their own channel. A resolved issue reappearing is worth waking up for. Filter on issue.unresolved and route regressions away from the noise of brand-new issues.

Assignments hit the team, not one inbox. Route issue.assigned events to a shared on-call or backend channel. The person who should look at it gets the push - whether or not they caught the email.

Critical metric alerts in seconds. Push metric_alert.critical and event_alert.triggered straight to the lock screen. SLO burn, error spikes, and p95 breaches surface immediately instead of waiting for someone to open Sentry.

One place for all your team's event routing. If you're already routing GitHub, Linear, or deployment events through ActivitySmith, Sentry alerts land in the same channels with the same setup.

What you can route

• Issue lifecycle events - created, assigned, resolved, ignored, unresolved - for new alerts, regressions, and team routing.
• Metric alert events - critical, warning, resolved - for SLO burn, error rate, and p95 latency breaches.
• Event alerts and error events for custom Sentry alert rules.
• Comment events so investigation activity reaches the right channel.
• Issue title, culprit, project, type, assignee, and metric alert status as payload fields for custom notification messages.
• Action buttons to open the issue in Sentry, mark it resolved, or trigger a webhook without unlocking your phone.

Use ActivitySmith to get Linear issue, cycle, and project events on your iOS devices based on priority, project, or label - not just whoever happens to be assigned or following the issue. Paste the generated endpoint into Linear, subscribe to the events you want, and route them into push notifications for your team.

Why use this if Linear already sends notifications

Linear's iOS app notifies you about issues you're assigned to or following. That works for your personal queue. It is not enough when the team wants routing based on severity, workflow stage, or project.

ActivitySmith puts those events on the lock screen and in the ActivitySmith log, so the right people see the handoff immediately.

Route by priority, not by assignment. Any P1 issue created in your workspace can go straight to #on-call. No one misses it because they weren't the assignee or weren't following the issue.

Shared sprint visibility. Cycle start and close events can land in a team channel so everyone knows the sprint boundary - without a standup or a manual message to check.

Visibility beyond Linear users. Managers, founders, or adjacent teams who don't live in Linear can still get the signal. Route project milestones and status changes to anyone with ActivitySmith - no Linear account required.

One place for all your team's event routing. If you're already routing GitHub Actions and deployment events through ActivitySmith, Linear fits into the same channels and the same setup.

What you can route

• Issue created, updated, started, completed, and cancelled events for issue workflow tracking.
• Cycle start and close events for team-wide sprint visibility.
• Project update and milestone events for stakeholders outside Linear.
• Issue identifiers, titles, assignees, priorities, and labels as payload fields for custom notification messages.

Use ActivitySmith to get GitHub deploys, pull requests, checks, and workflow runs on your iOS devices instead of refreshing Actions or waiting for email. Pair the generated endpoint with a GitHub repository or organization, pick the events you care about, and route them into push notifications or Live Activities for your team.

Push notifications are the right fit for handoffs and conclusions. Live Activities are a better fit for CI runs, deploys, and other long-running work you want visible from the lock screen while it is still moving.

Send handoffs as push notifications. Failed checks, merged pull requests, and deployment conclusions are moments someone should see right away. Route those events to the right channel so the next step is obvious the moment GitHub emits it.

Track long-running work with Live Activities. Workflow runs and deployment-style events are easier to follow as a single live line on the lock screen than as a pile of separate notifications.

What you can route

• Workflow, check run, and check suite activity for CI progress and conclusions.
• Pull requests, issues, comments, releases, and deployments for review and release visibility.

Use inbound webhooks when the service you care about does not have a native ActivitySmith integration yet. Railway deploys, GitLab pipelines, internal tools, and any custom JSON source can send events into ActivitySmith so your team sees backend work on the lock screen while it is still happening.

Choose Live Activities for rollouts, pipelines, and other long-running work. Choose push notifications for one-off outcomes, failures, and handoffs that someone should see immediately.

ActivitySmith accepts inbound webhooks from Railway, GitLab, and any service that sends custom JSON.

What's new

• Railway inbound webhooks for deployment events.
• GitLab inbound webhooks for pipelines, merge requests, issues, releases, comments, and repository events.
• Generic JSON webhooks for custom backend events and no-code tools.
• Delivery log for recent webhook requests, payloads, processing errors, and verification failures.

Webhooks also support secret-token verification and channel targeting, so incoming events can be checked before processing and routed to the right people and devices.

Railway deployment events

Railway deployment state can stay visible from rollout start to success or failure, without turning the release into another tab to watch.

For example, deployment start and progress events can update a Live Activity, then production success or failure can arrive as a Push Notification.

Good fits:

• production deploy started
• deployment failed
• rollback started
• deployment succeeded
• service metadata changed

GitLab pipeline and project events

GitLab pipeline, review, and release state can follow the work from the lock screen while it moves.

You can route pipeline events to Live Activities, send Push Notifications for failed jobs or review handoffs, and open the related GitLab page from the notification action.

Generic JSON webhooks

Generic webhooks are the escape hatch.

If a service can send JSON, it can send an event into ActivitySmith. Paste a sample payload, map JSON fields into the notification or Live Activity text, and choose the delivery mode that fits the event.

For optional verification, send the generated secret in:

X-ActivitySmith-Webhook-Secret: YOUR_SECRET

This is useful for internal tools, workers, cron jobs, low-code automations, or webhook providers that do not need a dedicated preset yet.

Delivery log

Inbound webhooks include a delivery log for the inevitable "did the webhook fire?" moment.

Availability

Inbound webhooks are available now in the ActivitySmith dashboard.

Start with Railway, GitLab, or Generic JSON, then choose whether that endpoint should deliver Push Notifications or Live Activities.

More integrations such as Vercel, Sentry, Stripe, and Polar are coming soon.

Live Activities now support a third activity type: metrics.

Use metrics to track server health, queue pressure, replica lag, worker saturation, and similar backend state you want visible on your lock screen at a glance.

1
const status = await activitysmith.liveActivities.stream("prod-web-1", {
2
  content_state: {
3
    title: "Server Health",
4
    subtitle: "prod-web-1",
5
    type: "metrics",
6
    metrics: [
7
      { label: "CPU", value: 9, unit: "%" },
8
      { label: "MEM", value: 45, unit: "%" },
9
    ],
10
  },
11
});

Call the same PUT /live-activity/stream/{stream_key} endpoint again whenever the values change. ActivitySmith keeps the Live Activity in sync on the device for you.

When the signal is no longer relevant, call DELETE /live-activity/stream/{stream_key} to end the Live Activity.

Need full lifecycle control instead?

If your runtime already has state, you can use the start/update/end lifecycle to have full control over the Live Activity.

1
const start = await activitysmith.liveActivities.start({
2
  content_state: {
3
    title: "Server Health",
4
    subtitle: "prod-web-1",
5
    type: "metrics",
6
    metrics: [
7
      { label: "CPU", value: 76, unit: "%" },
8
      { label: "MEM", value: 52, unit: "%" },
9
    ],
10
  },
11
});
12
13
const activityId = start.activity_id;

Store the returned activity_id and use the same metrics shape in update and end requests.

1
await activitysmith.liveActivities.update({
2
  activity_id: activityId,
3
  content_state: {
4
    ...
5
  },
6
});

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.5.0 and newer.

Live Activities now support a stateless stream mode.

I built this because while working on a new Live Activity type, I ran into a real limitation: lifecycle state management is fine in systems that already have state, but it becomes awkward in runtimes that wake up, do one thing, and exit.

GitHub Actions is a good example of where the original lifecycle still fits well. A workflow can start a Live Activity, keep the returned activity_id across steps, send updates, and end it when the run finishes.

A cron job is different. Each run can measure the current state of a process, but it does not naturally remember the activity_id from the previous run. You can bolt on a file, Redis key, or database row to persist it, but that means the integration is doing more state management than the job itself.

Stateless Live Activities remove that overhead.

What's new

• New PUT /live-activity/stream/{stream_key} endpoint for stateless start-or-update behavior.
• New DELETE /live-activity/stream/{stream_key} endpoint to end the tracked Live Activity when the process is over.
• ActivitySmith manages the lifecycle behind a stable stream_key, so the caller does not need to persist activity_id.
• This is a good fit for cron jobs, scheduled scripts, background workers, and polling loops.

How it works

Pick one stable stream_key for one thing you are tracking.

Examples:

• prod-web-1
• deployment-main
• nightly-backup
• ev-charging

Use one stream_key for one system, workflow, or process.

If no Live Activity exists yet for that key, ActivitySmith starts one. If one already exists, ActivitySmith updates it. If the current Live Activity needs to rotate, ActivitySmith handles that too.

The caller only sends the latest state.

Example: monitor PM2 process from cron

In this example, a cron job runs on a VPS, reads the CPU usage of one PM2 process by ID, maps that value to a progress Live Activity, and sends it with the same stream_key every time.

The important part is what the script does not do:

• it does not load an activity_id
• it does not save lifecycle state anywhere
• it just sends the latest data

1
#!/bin/bash
2
set -euo pipefail
3
4
API_BASE_URL="https://activitysmith.com/api"
5
API_KEY="YOUR_API_KEY"
6
STREAM_KEY="pm2-activitysmith-api-cpu"
7
PM2_PROCESS_ID="0"
8
9
cpu_raw=$(pm2 jlist | jq -r --arg id "$PM2_PROCESS_ID" '
10
  map(select((.pm2_env.pm_id | tostring) == $id)) | .[0].monit.cpu
11
')
12
13
if [ -z "$cpu_raw" ] || [ "$cpu_raw" = "null" ]; then
14
  exit 1
15
fi
16
17
cpu=$(printf "%.0f" "$cpu_raw")
18
19
if [ "$cpu" -gt 100 ]; then
20
  cpu=100
21
fi
22
23
if [ "$cpu" -ge 80 ]; then
24
  color="red"
25
elif [ "$cpu" -ge 40 ]; then
26
  color="yellow"
27
else
28
  color="green"
29
fi
30
31
payload=$(cat <<EOF
32
{
33
  "content_state": {
34
    "title": "API Health",
35
    "subtitle": "PM2 activitysmith-api CPU",
36
    "type": "progress",
37
    "percentage": $cpu,
38
    "color": "$color"
39
  }
40
}
41
EOF
42
)
43
44
curl --fail --silent --show-error \
45
  -X PUT "$API_BASE_URL/live-activity/stream/$STREAM_KEY" \
46
  -H "Authorization: Bearer $API_KEY" \
47
  -H "Content-Type: application/json" \
48
  -d "$payload"

Then let cron run it every minute:

* * * * * /opt/monitoring/pm2-cpu-live-activity.sh

One run might send a green update at normal CPU usage.

A later run can spike the same Live Activity to yellow.

That is the whole point of stream mode: each execution is stateless, but the Live Activity stays continuous on the device.

When to use which model

Use stream mode when the caller should only send the latest state and move on.

Good fits:

• cron jobs
• scheduled health checks
• queue depth samplers
• background workers
• scripts that run independently and exit

Keep the original start/update/end lifecycle when the caller already has a natural place to keep state.

Good fits:

• GitHub Actions workflows
• deploy orchestration
• import pipelines
• long-running jobs that already pass IDs between stages

Ending the stream

When the tracked process is over and you no longer want the Live Activity on devices, end the stream explicitly:

curl --fail --silent --show-error \
  -X DELETE "https://activitysmith.com/api/live-activity/stream/pm2-activitysmith-api-cpu" \
  -H "Authorization: Bearer YOUR_API_KEY"

If you later send another PUT request with the same stream_key, ActivitySmith starts a new Live Activity for that stream again.

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.5.0 and newer.

Live Activities now support optional action button.

Use it when a long-running job should stay actionable while progress is visible on the Lock Screen.

Open the GitHub Action run for a deployment, open a runbook, or trigger a backend webhook to pause or retry work without having to search for the right link or dashboard first.

What’s new

• New optional action field on Live Activity start, update, and end requests.
• One button per Live Activity.
• Action type:
  • open_url: opens the provided HTTPS URL in the browser.
  • webhook: ActivitySmith backend calls the provided HTTPS webhook (GET or POST).
• Supported for both segmented_progress and progress Live Activities.

Open URL example

Use this to jump from the Live Activity straight into the deployment or CI page.

1
{
2
  "content_state": {
3
    "title": "Deploying payments-api",
4
    "subtitle": "Running database migrations",
5
    "number_of_steps": 5,
6
    "current_step": 3,
7
    "type": "segmented_progress"
8
  },
9
  "action": {
10
    "title": "Open Workflow",
11
    "type": "open_url",
12
    "url": "https://github.com/acme/payments-api/actions/runs/1234567890"
13
  }
14
}

Webhook example

Use this when the action should trigger backend behavior instead of opening a page.

1
{
2
  "content_state": {
3
    "title": "Reindexing product search",
4
    "subtitle": "Shard 7 of 12",
5
    "number_of_steps": 12,
6
    "current_step": 7,
7
    "type": "segmented_progress"
8
  },
9
  "action": {
10
    "title": "Pause Reindex",
11
    "type": "webhook",
12
    "url": "https://ops.example.com/hooks/search/reindex/pause",
13
    "method": "POST",
14
    "body": {
15
      "job_id": "reindex-2026-03-19",
16
      "requested_by": "activitysmith"
17
    }
18
  }
19
}

Good fits

• deployment progress: open the workflow, deployment page, PR, or incident runbook
• customer imports and backfills: pause the import or retry a failed batch
• search reindex jobs: pause the reindex from the Live Activity itself
• database backup or restore verification: open the runbook or trigger the next backend step

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.4.0 and newer.

Push Notifications now support optional media.

Attach an image, video, or audio file to the notification itself so you can press and hold to preview media directly from the notification, then tap through to open the linked content.

This is a good fit for agent outputs, QA review flows, design previews, generated voice overs, and any backend workflow where the notification should carry the actual result, not just a line of text.

What’s new

• New optional media field for push notifications.
• Send direct image, video, or audio URLs in the payload.
• Press and hold to preview the media directly from the notification.
• media can be combined with redirection.
• If redirection is omitted, tapping the notification opens the media URL.

What will work

• direct image URL: .jpg, .png, .gif, etc.
• direct audio file URL: .mp3, .m4a, etc.
• direct video file URL: .mp4, .mov, etc.
• URL that responds with a proper media Content-Type, even if the path has no extension

Example payload

1
{
2
  "title": "Homepage ready",
3
  "message": "Your agent finished the redesign.",
4
  "media": "https://cdn.example.com/output/homepage-v2.png",
5
  "redirection": "https://github.com/acme/web/pull/482"
6
}

Availability

Available now across the API, SDKs, CLI, and GitHub Action.

This feature is available in the ActivitySmith iOS app version 1.3.0 and newer.

Live Activities now support a second activity type: progress.

Use progress when the work is naturally continuous instead of step-based.

It fits EV charging, file transfers, data sync progress, imports, downloads, uploads, and any job where a percentage or numeric range is clearer than "step 2 of 4".

What’s new

• New progress type for Live Activities.
• Send either percentage or value with upper_limit.
• Keep using segmented_progress for step-based workflows.
• segmented_progress still supports dynamic number_of_steps during update and end calls.

Choose the right type

• segmented_progress: best for jobs tracked in steps.
• progress: best for jobs tracked as a percentage or numeric range.

Lifecycle

The lifecycle stays the same:

1. Start the activity.
2. Save the returned activity_id.
3. Update it as progress changes.
4. End it when the work is finished.

Start Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 30 mi range",
5
    "percentage": 15,
6
    "type": "progress",
7
    "color": "lime"
8
  }
9
}

Update Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 120 mi range",
5
    "percentage": 60
6
  }
7
}

End Live Activity

1
{
2
  "content_state": {
3
    "title": "EV Charging",
4
    "subtitle": "Added 200 mi range",
5
    "percentage": 100,
6
    "auto_dismiss_minutes": 2
7
  }
8
}

Numeric range example

1
{
2
  "content_state": {
3
    "title": "Data Sync",
4
    "subtitle": "241 of 360 records synced",
5
    "value": 241,
6
    "upper_limit": 360,
7
    "type": "progress",
8
    "color": "blue"
9
  }
10
}

Availability

Available now across the API, SDKs, CLI, GitHub Action, and ActivitySmith skill.

This feature is available in the ActivitySmith iOS app version 1.2.0 and newer.

Push Notifications now support optional redirection and actions fields.

Use redirection to open a URL when a user taps the notification. Use actions to show up to four buttons on long-press.

What’s new

• redirection: HTTPS URL opened on notification tap.
• actions: up to 4 action buttons shown on long-press.
• Action type:
  • open_url: opens the provided URL in browser.
  • webhook: triggers backend webhook call (GET or POST).

Availability

This feature is available in the ActivitySmith iOS app version 1.1.0 and newer.

Example payload

1
{
2
  "title": "Build Failed 🚨",
3
  "message": "CI pipeline failed on main branch",
4
  "redirection": "https://github.com/org/repo/actions/runs/123456789",
5
  "actions": [
6
    {
7
      "title": "Open Failing Run",
8
      "type": "open_url",
9
      "url": "https://github.com/org/repo/actions/runs/123456789"
10
    },
11
    {
12
      "title": "Create Incident",
13
      "type": "webhook",
14
      "url": "https://hooks.example.com/incidents/create",
15
      "method": "POST",
16
      "body": {
17
        "service": "payments-api",
18
        "severity": "high"
19
      }
20
    }
21
  ]
22
}

All SDKs, CLI, and the GitHub Action now support these optional fields in push notification requests.

ActivitySmith now provides a skill you can install with npx skills add to send Push Notifications and trigger Live Activities from your coding agents.

Install

npx skills add ActivitySmithHQ/activitysmith-cli --skill activitysmith

Repository: github.com/activitysmithhq/activitysmith-cli

Push notification example

./skills/activitysmith/scripts/send_push.sh \
  -t "Codex task finished" \
  -m "Implemented OAuth callback fix, added regression tests, and opened PR #128."

Live Activity workflow example

1
activity_id="$(./skills/activitysmith/scripts/start_activity.sh \
2
  --title "Codex: migrate billing webhooks" \
3
  --subtitle "Analyzing handlers" \
4
  --type "segmented_progress" \
5
  --steps 4 \
6
  --current 1 \
7
  --id-only)"
8
9
./skills/activitysmith/scripts/update_activity.sh \
10
  --activity-id "$activity_id" \
11
  --title "Codex: migrate billing webhooks" \
12
  --subtitle "Implementing + tests" \
13
  --current 2
14
15
./skills/activitysmith/scripts/end_activity.sh \
16
  --activity-id "$activity_id" \
17
  --title "Codex: migrate billing webhooks" \
18
  --subtitle "Done" \
19
  --current 4 \
20
  --auto-dismiss 2

Use ACTIVITYSMITH_API_KEY for auth in your shell or environment.

ActivitySmith now integrates with Zapier so you can send iOS Push Notifications and Live Activities from your automations.

Connect ActivitySmith to any Zap and route runtime events from your apps, scripts, and workflows to paired team devices.

Supported actions

• Send push notifications for immediate events.
• Start and update Live Activities for long-running workflows.

Visit ActivitySmith integration on Zapier for more details.

Use channels to route Push Notifications and Live Activities to specific users and devices.

Channels are now supported across all ActivitySmith SDKs and integrations, and the documentation has been updated with channel examples.

You can also scope API keys to specific channels for tighter control over where updates can be delivered.

Why channels

Channels let you route updates to the right audience, for example: #engineering, #ios-builds, #marketing.

Example

1
{
2
  "title": "Build Failed",
3
  "message": "CI pipeline failed on main branch",
4
  "channels": ["ios-builds", "engineering"]
5
}

If channels are omitted, delivery behavior stays unchanged.

Add your team members to keep everyone notified and up to date with shared Push Notifications and Live Activities.

When your backend, scripts, or automations send Push Notifications or Live Activities, each update is delivered to all paired iOS devices on your team.

How it works

1. Add team members in ActivitySmith.
2. Teammates accept the invite and pair their iOS devices.
3. Send updates from your backend, scripts, automations, or AI agents.
4. Everyone gets notified and up to date with Push Notifications and Live Activities.

The official ActivitySmith SDK suite is now available across all major backend stacks.

You can now integrate ActivitySmith with:

• Node.js (npm)
• Python (PyPI)
• Go
• PHP (Packagist)
• Ruby (RubyGems)
• CLI

Install

1
# Node.js SDK
2
npm i activitysmith
3
4
# Python SDK
5
pip install activitysmith
6
7
# Go SDK
8
go get github.com/ActivitySmithHQ/activitysmith-go
9
10
# PHP SDK
11
composer require activitysmith/activitysmith
12
13
# Ruby SDK
14
gem install activitysmith
15
16
# ActivitySmith CLI
17
npm i -g activitysmith-cli

Documentation

Full SDK documentation:

• activitysmith.com/docs/sdks/overview

The official ActivitySmith GitHub Action is now live on the GitHub Marketplace.

Connect your CI and deployment workflows directly to ActivitySmith so your team gets real-time updates on their mobile devices.

You can now:

• Send push notifications from any workflow step.
• Start, update, and end Live Activities as your pipeline progresses.

Push Notifications

For lightweight updates like deploy completed, build failed, or rollback started, send a push notification in a single step:

1
- name: Send push notification
2
  uses: ActivitySmithHQ/[email protected]
3
  with:
4
    action: send_push_notification
5
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
6
    payload: |
7
      title: "ActivitySmith Deployment"
8
      message: "New release deployed to production."

This is a good fit for one-off alerts where you want immediate visibility but no ongoing activity timeline.

Live Activities

For long-running workflows, start the activity, post as many progress updates as needed, then end it when complete.

The start_live_activity step returns live_activity_id, which you pass into update/end steps.

1
- name: Start live activity
2
  id: start_activity
3
  uses: ActivitySmithHQ/[email protected]
4
  with:
5
    action: start_live_activity
6
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
7
    payload: |
8
      content_state:
9
        title: "ActivitySmith API Deployment"
10
        subtitle: "ci: install & build"
11
        number_of_steps: 3
12
        current_step: 1
13
        type: "segmented_progress"
14
15
- name: Update live activity
16
  uses: ActivitySmithHQ/[email protected]
17
  with:
18
    action: update_live_activity
19
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
20
    live-activity-id: ${{ steps.start_activity.outputs.live_activity_id }}
21
    payload: |
22
      content_state:
23
        title: "ActivitySmith API Deployment"
24
        subtitle: "ci: tests"
25
        current_step: 2
26
27
- name: End live activity
28
  uses: ActivitySmithHQ/[email protected]
29
  with:
30
    action: end_live_activity
31
    api-key: ${{ secrets.ACTIVITYSMITH_API_KEY }}
32
    live-activity-id: ${{ steps.start_activity.outputs.live_activity_id }}
33
    payload: |
34
      content_state:
35
        title: "ActivitySmith API Deployment"
36
        subtitle: "done"
37
        current_step: 3

After months of building, ActivitySmith is live! Trigger Live Activities and send Push Notifications to your iOS device(s) with a simple API call.

Start here:

• Download the ActivitySmith iOS app and pair your device.
• Create API key and use the REST API to trigger Live Activities and send Push Notifications from any backend or CI.
• Check Quickstart guide at activitysmith.com/docs.

Try it now at activitysmith.com.