The idea​

GitHub Actions can run a curl command. Pushmark receives that request and sends a push notification to your iPhone in seconds. No server, no APNs certificates, no notification infrastructure to maintain — just a few lines of YAML and a free Pushmark account.

Deploy notifications​

Get notified the moment a deployment succeeds. Add this workflow to your repository:

name: Notify deploy

on:
  check_run:
    types: [completed]

jobs:
  notify:
    if: github.event.check_run.conclusion == 'success'
    runs-on: ubuntu-latest
    steps:
      - name: Send Pushmark notification
        run: |
          curl -X POST "https://api.pushmark.app/YOUR_CHANNEL_HASH" \
            -H "Content-Type: application/json" \
            -d '{
              "type": "log",
              "message": {
                "status": "${{ github.event.check_run.conclusion }}",
                "context": "${{ github.event.check_run.name }}",
                "url": "${{ github.event.check_run.html_url }}",
                "commit": "${{ github.event.check_run.head_sha }}",
                "triggered_by": "${{ github.event.sender.login }}"
              }
            }'

Replace YOUR_CHANNEL_HASH with the hash from your Pushmark channel page.

Build failure alerts​

The most valuable notification is the one that wakes you up when something breaks. Use type: "error" to make it stand out:

name: Notify build failure

on:
  check_run:
    types: [completed]

jobs:
  notify:
    if: github.event.check_run.conclusion == 'failure'
    runs-on: ubuntu-latest
    steps:
      - name: Send Pushmark notification
        run: |
          curl -X POST "https://api.pushmark.app/YOUR_CHANNEL_HASH" \
            -H "Content-Type: application/json" \
            -d '{
              "type": "error",
              "message": {
                "status": "failed",
                "check": "${{ github.event.check_run.name }}",
                "url": "${{ github.event.check_run.html_url }}",
                "commit": "${{ github.event.check_run.head_sha }}",
                "triggered_by": "${{ github.event.sender.login }}"
              }
            }'

PR merge notifications​

Know when a pull request lands on your main branch without watching the repository:

name: Notify PR merged

on:
  pull_request:
    types: [closed]
    branches: [main]

jobs:
  notify:
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
    steps:
      - name: Send Pushmark notification
        run: |
          curl -X POST "https://api.pushmark.app/YOUR_CHANNEL_HASH" \
            -H "Content-Type: application/json" \
            -d '{
              "type": "success",
              "message": {
                "pr": "${{ github.event.pull_request.title }}",
                "merged_by": "${{ github.event.pull_request.merged_by.login }}",
                "branch": "${{ github.event.pull_request.head.ref }}",
                "url": "${{ github.event.pull_request.html_url }}"
              }
            }'

Setup​

1. Download the Pushmark app and create a channel — give it a name like "GitHub alerts"
2. Copy the channel hash from the channel detail page
3. Add the workflow YAML to .github/workflows/ in your repository
4. Replace YOUR_CHANNEL_HASH with your channel hash

The next time a deploy finishes or a build breaks, you'll feel your phone buzz before you've switched windows.

Why Pushmark​

Sending a GitHub notification to your iPhone normally means: configuring email alerts (noisy), setting up Slack (another tool), or building a webhook receiver with APNs credentials (real infrastructure). This pattern skips all of that. Download the app, create a channel, and you're done. Pushmark handles the APNs side. GitHub Actions handles the trigger. You just write a curl command.

See the Getting Started guide for the full API reference and payload options.

There's a better way: feel it happen in real time.

The idea​

Pushmark is a free iOS app that receives push notifications triggered by a simple HTTP POST. Install it on your phone, create a channel, and anything that can make an HTTP request can notify you — including your own apps. On first launch, your app fires a single POST to that channel, and your phone buzzes instantly. No backend, no APNs certificates, no provisioning headaches.

Setup​

1. Download Pushmark on your iPhone
2. Create a channel — give it a name like "MyApp installs"
3. Copy the channel hash from the channel detail page

SwiftUI implementation​

Replace YOUR_CHANNEL_HASH with the hash you just copied, then add a notifyInstall() function and call it from your root view's .onAppear modifier:

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .onAppear { notifyInstall() }
        }
    }
}

func notifyInstall() {
    let defaults = UserDefaults.standard
    let key = "hasLaunchedBefore"

    guard !defaults.bool(forKey: key) else { return }
    // Flag set before the network call (fire-and-forget — no retry on failure)
    defaults.set(true, forKey: key)

    let channelHash = "YOUR_CHANNEL_HASH"
    let url = URL(string: "https://api.pushmark.app/\(channelHash)")!

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")

    let locale = Locale.current.identifier
    let version = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown"
    let appName = Bundle.main.infoDictionary?["CFBundleName"] as? String ?? "App"

    let body: [String: Any] = [
        "message": [
            "app": appName,
            "version": version,
            "locale": locale
        ],
        "type": "success"
    ]

    request.httpBody = try? JSONSerialization.data(withJSONObject: body)

    URLSession.shared.dataTask(with: request).resume()
}

The .onAppear modifier runs once when the root view appears. The UserDefaults flag ensures it only fires on the very first launch.

That's it. The next time someone opens your app for the first time, you'll feel your phone buzz.

Richer notifications​

The message object is freeform. Include whatever context matters to you:

let body: [String: Any] = [
    "message": [
        "app": appName,
        "version": version,
        "locale": Locale.current.regionCode ?? "??",
        "timezone": TimeZone.current.identifier
    ],
    "type": "success"
]

Common fields to add:

• Locale.current.regionCode — country (e.g. US, DE, JP)
• Locale.current.identifier — full locale (e.g. en_US)
• TimeZone.current.identifier — timezone
• Bundle.main.infoDictionary?["CFBundleShortVersionString"] — app version

Why Pushmark​

Getting push notifications to your device from an iOS app normally requires a server with APNs credentials, a provider token or certificate, and a registered push token from the target device. That's the right setup for production apps sending notifications to users.

This pattern is for a different case: you want to notify yourself, and you want zero infrastructure. Pushmark handles the APNs side. Your app just makes an HTTP POST.

See the Getting Started guide for the full API reference.