CI/CD Integration for React Native OTA Updates — Automate, Test, and Ship

Supported CI/CD Platforms

You don't need to replace your CI/CD system to automate OTA releases. Stallion works with popular CI/CD platforms through its CLI, CI tokens, and platform-specific integrations where available.

From Merge to Production

A good CI/CD workflow shouldn't just upload an OTA bundle. It should control how that bundle reaches users.

With Stallion, your pipeline can publish an artifact, validate it, promote it to the right app version, and control how the release rolls out.

Publish → Test → Promote → Roll out

This separation lets teams automate routine releases while keeping production rollout behind the approval and release gates that make sense for their workflow.

Automate Releases Securely With CI Tokens

Stallion supports CI/CD automation through CI tokens designed for use in automated pipelines. Store the token in your CI provider's secret manager instead of putting a developer credential into your workflow.

Step 1: Generate a CI Token

From the Stallion Console:

1. Go to Project Settings
2. Open Access Tokens
3. Generate a CI Token

Step 2: Store It as a CI/CD Secret

Store the token in your CI provider's secret store—GitHub Secrets, Bitrise Secrets, or your provider's equivalent. Use the narrowest available token scope and rotate or revoke credentials if they are compromised.

Step 3: Use the Token in the CLI

npx stallion publish-bundle \
  --upload-path=org-name/project-name/bucket \
  --platform=android \
  --release-note="your release notes" \
  --ci-token="your-ci-token"

Automate OTA Publishing With GitHub Actions

If your team already uses GitHub Actions, adding OTA publishing can be as simple as one additional release step.

name: Publish OTA with Stallion

on:
  push:
    branches:
      - main

jobs:
  publish:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v6

      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20

      - name: Install dependencies
        run: npm ci

      - name: Publish OTA Update with Stallion
        run: |
          COMMIT_MSG=$(git log -1 --pretty=format:"%s")
          echo "Publishing with commit message: $COMMIT_MSG"

          npx stallion publish-bundle \
            --upload-path=my-org/my-project/prod \
            --platform=android \
            --release-note="$COMMIT_MSG" \
            --ci-token="${{ secrets.STALLION_CI_TOKEN }}"

Store your CI token as a GitHub secret named STALLION_CI_TOKEN for secure access in your workflows.

Control the Full Release Lifecycle

For teams that need more control than a single publish command, Stallion separates bundle publishing from release promotion and rollout configuration.

That means your pipeline can:

1. Publish the OTA bundle.
2. Capture the bundle hash.
3. Promote the bundle to the target app version.
4. Set rollout percentage.
5. Mark the release as mandatory when appropriate.

Need the complete workflow? See the CI/CD documentation →

Complete GitHub Actions Workflow

A complete workflow that publishes bundles, extracts hash, releases, and updates rollout configuration:

name: Stallion Release Automation

on:
  push:
    branches:
      - main

jobs:
  release-bundle:
    runs-on: ubuntu-latest

    env:
      PROJECT_ID: 64f5f341a43eb5ccf93548e4
      APP_VERSION: 1.0.1
      RELEASE_NOTE: "Automated CI Release"
      CI_TOKEN: ${{ secrets.STALLION_CI_TOKEN }}
      UPLOAD_PATH: my-org/my-project/my-bucket
      PLATFORM: android

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install Stallion CLI
        run: npm install -g stallion-cli

      - name: Publish Bundle and Extract Hash
        id: publish
        run: |
          echo "Publishing bundle..."
          OUTPUT=$(stallion publish-bundle \
            --upload-path=$UPLOAD_PATH \
            --platform=$PLATFORM \
            --release-note="$RELEASE_NOTE")

          echo "$OUTPUT"

          HASH=$(echo "$OUTPUT" | grep -oE '[a-f0-9]{64}')
          echo "Bundle hash: $HASH"

          echo "BUNDLE_HASH=$HASH" >> $GITHUB_ENV

      - name: Release Bundle
        run: |
          stallion release-bundle \
            --project-id=$PROJECT_ID \
            --hash=$BUNDLE_HASH \
            --app-version=$APP_VERSION \
            --release-note="$RELEASE_NOTE" \
            --ci-token=$CI_TOKEN

      - name: Update Release (optional rollout config)
        run: |
          stallion update-release \
            --project-id=$PROJECT_ID \
            --hash=$BUNDLE_HASH \
            --release-note="$RELEASE_NOTE" \
            --rollout-percent=100 \
            --is-mandatory=true \
            --ci-token=$CI_TOKEN

Instant QA with Stallion Testing Framework

Shipping an update is only half the workflow. Your team also needs a fast way to validate the release before pushing it broadly.

Stallion Testing lets authorized testers switch between available OTA releases directly inside a released React Native app using the built-in SDK modal.

No rebuilds. No TestFlight. No APK uploads. Just deploy, switch, and test.

A QA build doesn't have to wait for another native build. Once an OTA release is published, authorized testers can switch to it from the app, validate the change, and move on to the next release candidate—shortening the feedback loop between developer → QA → release without creating another native build for every JavaScript release.

Integrate Stallion Modal

import { useStallionModal } from "react-native-stallion";

const MyDebugScreen = () => {
  const { showModal } = useStallionModal();

  return <Button title="Open Stallion" onPress={showModal} />;
};

Set Up Security Pin

Set a security PIN in the Stallion Console to restrict access to internal testers. Authorized testers can open the Stallion modal, select an available OTA release, download it, and restart the app to validate the version.

Benefits of CI/CD Integration

Related Resources