# Rollbird vs Stallion

Stallion and Rollbird are both hosted services that push new JavaScript
bundles to React Native apps already installed from the App Store and Google
Play. Stallion has its own SDK, CLI and console, with a free plan to 10,000
monthly active users. Rollbird, a hosted React Native OTA update service, has
flat plans that don't count users. This page is for teams weighing a Stallion
alternative: it walks one release through both tools command by command, maps
Stallion's buckets and releases to Rollbird's channels, compares cost at three
app sizes, and lists where Stallion is the stronger pick.

Rollbird publishes this page. Stallion details come from its
[pricing page](https://stalliontech.io/pricing) and
[documentation](https://stalliontech.io/learn/docs/introduction), checked
October 2026.

## At a glance

| Topic | Stallion | Rollbird |
| --- | --- | --- |
| Price model | Plans by monthly active users (MAU) with download and upload bandwidth allowances; Pro allows overage, Free is capped | Flat plans priced on apps, storage and seats; users and bandwidth are not metered |
| Free tier | 10,000 MAU and 50 GB of downloads a month, unlimited collaborators | 1 app, 3 production releases a month and 1 member, any number of users |
| Client library | `react-native-stallion` (MIT) with `withStallion(App)` | `@rollbird/react-native` with `Rollbird.wrap`, built on Hot Updater's client |
| CLI | `stallion-cli`: `login`, `publish-bundle`, `release-bundle`, `update-release`, `generate-key-pair` | `rollbird`: `login`, `init`, `release`, `rollback`, `status` |
| Native setup | Edit `MainApplication` and `AppDelegate`, copy a project ID and app token into `strings.xml` and `Info.plist` | `rollbird init` writes the native configuration and signing key |
| Platforms per publish | One: `--platform=ios` or `--platform=android` | Both detected platforms, unless you pass `--platform` |
| Release targeting | The app version you enter when promoting | Native fingerprint by default, or app version |
| Staged rollout | Starts at 0%; raise it in the console or with `update-release`; it can't be lowered | Set with `rollbird release --rollout`, adjustable in the dashboard |
| Rollback | Console or `update-release --is-rolled-back=true` | `rollbird rollback`, always free and never blocked by plan limits |
| Differential updates | Yes, patch updates; limited on the Free plan | No |
| React Native | 0.69 or newer | 0.76 is the verified baseline |
| Expo | `expo-stallion-plugin`, then export and publish each platform's bundle | Config plugin for Expo 50 or newer; `rollbird release` builds the bundles |

## One release on both platforms, staged to 10%

Here is the same job in each tool: ship one JavaScript fix to iOS and Android
production users, start at 10%, go to everyone, then undo it. The Stallion
column follows its
[publish](https://stalliontech.io/learn/docs/cli/usage-api-reference),
[release](https://stalliontech.io/learn/docs/cli/release-bundle-api-reference)
and [update](https://stalliontech.io/learn/docs/cli/update-release-api-reference)
references and its [production guide](https://stalliontech.io/learn/docs/sdk/production-usage).
The Rollbird column follows the [CLI reference](https://rollbird.dev/docs/cli/).

| Step | Stallion | Rollbird |
| --- | --- | --- |
| Before the first upload | Create a bucket in the Stallion console | Nothing; the channel was embedded by `rollbird init` |
| Build and upload iOS | `stallion publish-bundle --upload-path=<org>/<project>/<bucket> --platform=ios` | `npx rollbird release --production --rollout 10 --yes` builds, signs and uploads both platforms |
| Build and upload Android | `stallion publish-bundle --upload-path=<org>/<project>/<bucket> --platform=android` | Included in the command above |
| Make it a production release | Promote each bundle in the console with the target app version (admins only), or run `stallion release-bundle --project-id=<id> --hash=<hash> --app-version=<version> --ci-token=<token>` once per platform | Included: `--production` publishes to the production channel |
| Start at 10% | The new release begins at 0%; run `stallion update-release --project-id=<id> --hash=<hash> --rollout-percent=10 --ci-token=<token>` per platform, or use Manage Release in the console | Included: `--rollout 10` |
| Go to 100% | `update-release` again with `--rollout-percent=100`, per platform | Raise the percentage in the dashboard |
| Undo it | `update-release --is-rolled-back=true` per platform, or roll back in the console | `npx rollbird rollback` |

`release-bundle` and `update-release` only work with a CI token from the
project settings; without one, promotion and rollout happen in the console. In Rollbird, the same `rollbird release` command runs on a
laptop after `rollbird login` and in CI with a project-bound `ROLLBIRD_TOKEN`;
see [CI/CD](https://rollbird.dev/docs/ci/).

Two rollout rules from Stallion's
[phased rollout guide](https://stalliontech.io/learn/docs/phased-rollout)
are worth knowing before you plan a release. A percentage can be raised,
paused or rolled back, but not lowered. And a user outside the newest
release's percentage gets the previous release only if that one is at 100%;
otherwise they get no update.

## How the concepts map

| Stallion | Rollbird | Notes |
| --- | --- | --- |
| Organization | Organization | Both hold members and projects. |
| Project, linked by `StallionProjectId` and `StallionAppToken` in native files | Project, linked by `rollbird init` and the public key in `rollbird.json` | Rollbird has no token to paste into native files. |
| One project per app flavour (dev, QA, production) | One project, one channel per build: `rollbird init --channel preview`, then `--channel production` | A binary only requests the channel it was built with. |
| Bucket of uploaded bundles, used by the in-app testing modal | The `preview` channel | Testers run a build made with `--channel preview` and receive its releases. |
| Bundle, one per platform, identified by a hash | One release holding the iOS and Android bundles | |
| Release: a bundle promoted for an app version | A production release, matched by native fingerprint or app version | With the fingerprint default, a release only reaches binaries with the same native code. |
| `--is-mandatory=true` | `rollbird release --force` | Rollbird reloads after download unless `reloadOnForceUpdate` is `false`. |
| `stallion generate-key-pair` and `--private-key` | Provisioned by `rollbird init`; every release is signed | |
| CI token | Project-bound API token in `ROLLBIRD_TOKEN` | |

## What each costs at 10,000, 100,000 and 1,000,000 users

Stallion prices come from its [pricing page](https://stalliontech.io/pricing),
checked October 2026. Its Pro plan allows usage beyond 100,000 users and bills
the overage monthly, but the page doesn't publish the overage rate, so this
table doesn't guess one. Rollbird prices come from
[the pricing section](https://rollbird.dev/#pricing).

| Monthly active users | Stallion | Rollbird |
| --- | --- | --- |
| 10,000 | $0 on Free, which stops at 10,000 users and 50 GB of downloads a month | $0 on Free for one app shipping up to 3 production releases a month; otherwise $7 on Indie |
| 100,000 | $64 a month on Pro, or $51 a month billed yearly; 2 TB of downloads included | $7 on Indie for up to 3 apps |
| 1,000,000 | Pro plus overage at an unpublished rate, or Enterprise at a custom price | $7 on Indie for up to 3 apps |

Rollbird's bill changes with apps, storage and seats, not users: Indie is $7 a
month for 3 apps, 2 GiB and one member; Team is $15 for 10 apps, 10 GiB and 3
members; Studio is $29 for unlimited apps, 50 GiB and 10 members. Yearly
billing costs ten months.

## Moving from Stallion to Rollbird

Run one update client per app. Stallion and Rollbird both choose the bundle
the app loads at launch, so remove Stallion's wiring before `rollbird init`
adds its own. The Stallion column comes from its
[installation](https://stalliontech.io/learn/docs/sdk/installation),
[bundle signing](https://stalliontech.io/learn/docs/bundle-signing) and
[Expo](https://stalliontech.io/learn/docs/expo-integration-with-stallion)
guides.

| File | Stallion lines to remove | What Rollbird uses |
| --- | --- | --- |
| `package.json` | `react-native-stallion`, plus `expo-stallion-plugin` and `stallion-cli` if installed | `@rollbird/react-native`, installed by `rollbird init`, and `@rollbird/cli` as a dev dependency |
| `MainApplication` | `import com.stallion.Stallion` and `Stallion.getJSBundleFile(...)` in `getJSBundleFile()` or `jsBundleFilePath` | Bundle entry point wired by `rollbird init` |
| `strings.xml` | `StallionProjectId`, `StallionAppToken`, `StallionPublicSigningKey` | Channel and fingerprint, written by `rollbird init`; the public signing key goes in `AndroidManifest.xml` |
| `AppDelegate` | The Stallion import and `StallionModule.getBundleURL()` in `bundleURL` | Release bundle URL wired by `rollbird init` |
| `Info.plist` | `StallionProjectId`, `StallionAppToken`, `StallionPublicSigningKey` | Channel, public signing key and fingerprint, written by `rollbird init` |
| App root component | `withStallion(App)`, and any `useStallionUpdate` or `restart` calls | `Rollbird.wrap({ projectKey })(App)`; `Rollbird.reload()` for a custom restart |
| `app.json` (Expo) | The `expo-stallion-plugin` entry with `projectId`, `appToken` and `publicSigningKey` | The `@rollbird/react-native` plugin entry, registered by `rollbird init` |

Then:

1. Uninstall the Stallion packages and run `pod install` for iOS.
2. Remove the native lines above, so the entry points match a fresh React Native template.
3. Run `npx rollbird login`, then `npx rollbird init --channel preview`, and read the diff before committing it.
4. Replace `withStallion(App)` with `Rollbird.wrap`, rebuild, and check a preview release and a rollback on a device with [Getting started](https://rollbird.dev/docs/getting-started/).
5. Run `npx rollbird init --channel production`, build the store binary, and submit it.
6. In CI, replace `publish-bundle`, `release-bundle` and `update-release` with one `rollbird release --production --yes`.

For example, remove the SDK with npm:

```bash
npm uninstall react-native-stallion
```

Builds already on users' phones keep asking Stallion for updates until they
install the new store version. Keep your Stallion project serving until most
users have upgraded.

## Where Stallion is the better choice

- **Small apps that release often.** Up to 10,000 users, Stallion Free lists no release limit and includes unlimited collaborators. Rollbird Free allows one app, 3 production releases a month and one member; beyond that it's $7 a month.
- **Download size matters.** Stallion ships patch updates that contain only what changed since the previous version. Rollbird downloads the full bundle every time.
- **In-app QA.** Stallion's SDK has a testing modal where testers pick a bucket and install any bundle from it without promoting it. Rollbird testers use a preview build on the preview channel.
- **Custom update prompts.** Stallion checks on every restart and resume and exposes `useStallionUpdate`, `sync` and `restart` for your own UI. Rollbird checks on launch and applies the update on the next launch, with `checkForUpdate` and `reload` for explicit control.
- **Older React Native.** Stallion supports React Native 0.69 and newer. Rollbird's verified baseline is 0.76.
- **Procurement and compliance.** Stallion's Enterprise plan offers SSO, an uptime SLA, a SOC 2 report and purchase through AWS Marketplace, and an On-Premise plan runs it on your own infrastructure.

## Where Rollbird fits

- **Audiences past 100,000 users.** The plan doesn't depend on users or download bandwidth, so growth doesn't move the bill or push you into a custom quote.
- **One command per release.** `rollbird release` bundles, signs and uploads iOS and Android together and can set the rollout percentage in the same step, from a laptop or CI.
- **Nothing to copy by hand.** `rollbird init` writes the channel, signing key and fingerprint into the native projects, or into `rollbird.json` for Expo, instead of IDs and tokens pasted from a console.
- **Releases matched to native code.** The default fingerprint strategy offers a release only to binaries built from the same native state, so you don't track app versions per release.
- **Recovery that is always available.** Rollback is free, consumes no release quota and still works when a plan or storage limit blocks new releases. A bundle that crashes before reporting ready falls back to the previous one.

To try it, follow [Getting started](https://rollbird.dev/docs/getting-started/)
from installation to a verified preview update and rollback. For a wider view
of hosted and self-hosted options, see
[CodePush alternatives in 2026](https://rollbird.dev/docs/codepush-alternatives/).