Stallion logo

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

Modern React Native development requires automation. CI/CD pipelines, instant testing, and faster rollouts define high-performance mobile teams. React Native Stallion provides first-class support for CI/CD workflows and a blazing-fast testing system built right into your app.

Automate OTA bundle releases via CI/CD, use GitHub Actions to publish on every main merge, and slash dev-to-QA time using Stallion's version switching UI. React Native Stallion supports popular CI/CD platforms including GitHub Actions, Bitrise, CircleCI, Expo, Jenkins, Appcircle, and Codemagic.

Supported CI/CD Platforms

React Native Stallion seamlessly integrates with all major CI/CD platforms:

GitHub Actions

Automate OTA releases with GitHub Actions workflows. Publish bundles automatically on every push to main.

Bitrise

Native Bitrise integration with dedicated steps for automated CodePush deployments and OTA updates.

CircleCI

CircleCI Orb support for seamless automation of your CI/CD CodePush workflow with React Native Stallion.

Expo

Full Expo integration support for EAS builds and automated OTA update deployments.

Jenkins

Jenkins pipeline integration for enterprise teams requiring on-premise CI/CD automation.

Appcircle & Codemagic

Support for Appcircle and Codemagic CI/CD platforms with automated React Native OTA update workflows.

Automate Releases with CI/CD Integration

React Native Stallion supports CI/CD automation via CI tokens. These tokens are safe for CI pipelines and scoped only for publishing bundles.

Step 1: Generate a CI Token

From your React Native Stallion Console:

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

Step 2: Use the Token in CLI

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

GitHub Actions: Auto Publish on Main

Automate OTA bundle publishing on every push to your main branch using GitHub Actions:

name: Publish OTA with Stallion

on:
  push:
    branches:
      - main

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "18"

      - 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.

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

Stallion CLI Commands for CI/CD

Publishing a Bundle

stallion publish-bundle \
  --upload-path=orgname/project-name/bucket-name \
  --platform=android/ios \
  --release-note="Your release note here"

Promoting a Bundle

stallion release-bundle \
  --project-id=<your_project_id> \
  --hash=<bundle_hash> \
  --app-version=<target_app_version> \
  --release-note="Your release note" \
  --ci-token=<your_ci_token>

Updating a Release

stallion update-release \
  --project-id=<your_project_id> \
  --hash=<bundle_hash> \
  --release-note="Updated release note" \
  --rollout-percent=<percent> \
  --is-mandatory=<true|false> \
  --ci-token=<your_ci_token>

Instant QA with Stallion Testing Framework

Shipping updates is half the battle. Testing them quickly is just as important. Stallion Testing lets your team install any version of the app directly inside the released app using a built-in SDK modal.

No rebuilds. No TestFlight. No APK uploads. Just deploy, tap, and test. Stallion lets you switch between app versions instantly, speeding up QA/dev cycles.

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 your React Native Stallion Console to restrict internal tester access. After upload, the build shows up inside the Stallion modal. Anyone can install it by clicking the download button and restarting the app.

Benefits of CI/CD Integration

Automated Releases

Publish OTA updates automatically on every merge to main. No manual intervention required.

Faster QA Cycles

Test builds instantly using Stallion's version switching UI. Slash dev-to-QA time significantly.

Consistent Workflows

Standardize your release process across all platforms and environments with CI/CD automation.

Secure Token Management

CI tokens are scoped only for publishing bundles, ensuring security in your CI/CD pipelines.

Related Resources

Frequently Asked Questions

Does React Native Stallion support GitHub Actions?

Yes, React Native Stallion has full support for GitHub Actions. You can automate OTA bundle publishing on every push to main using our CLI and CI tokens. See the GitHub Actions example above for a complete workflow.

Can I use React Native Stallion with Bitrise?

Yes, React Native Stallion integrates seamlessly with Bitrise. Use our CLI commands in your Bitrise workflows to automate OTA updates. Native Bitrise steps are available for streamlined integration.

How do I secure CI tokens in my CI/CD pipeline?

Store your CI token as a secret in your CI/CD platform (GitHub Secrets, Bitrise Secrets, etc.). CI tokens are scoped only for publishing bundles, ensuring security. Never commit tokens to your repository.

What is the Stallion Testing Framework?

The Stallion Testing Framework lets your team install any version of the app directly inside the released app using a built-in SDK modal. No rebuilds, no TestFlight, no APK uploads. Just deploy, tap, and test. This dramatically speeds up QA cycles.