Every endpoint below is authenticated with a project API token (generate one on a project's Collaborators page) via Authorization: Bearer <token>. A token is scoped to exactly one project.
An org admin can instead generate an organization token (on an org's Settings page) — it uses the same Authorization: Bearer <token> header, but is always read-only and has no project of its own, so every /api/v1/* request made with one must name a project in that org via a ?projectId= query parameter. /api/ci/releases/create (publishing) does not accept organization tokens at all — publishing always requires a project token.
/api/ci/releases/createPublish a new release — the same endpoint CI pipelines use.
curl -X POST https://your-app/api/ci/releases/create \ -H "Authorization: Bearer qap_..." \ -F platform=ios -F version=1.2.0 -F bundleId=com.company.app \ -F channel=beta -F file=@app.ipa
/api/v1/releasesList the project's published releases, newest first (?limit=1-100, default 20).
curl https://your-app/api/v1/releases \ -H "Authorization: Bearer qap_..."
/api/v1/releases/:idFetch a single release's detail.
curl https://your-app/api/v1/releases/<release-id> \ -H "Authorization: Bearer qap_..."
/api/v1/check-updateAsk whether a newer build exists for a platform+channel than the one the caller is currently running. Params: platform (ios|android|web, required), currentVersion (required), currentBuildNumber (optional, tiebreaker), channel (optional, default production), deviceId (optional — a stable per-device identifier; if a release has a staged rollout percentage set, a device is bucketed by this id and only sees the new build once it falls within that percentage; if a release is scoped to 'registered devices only' (iOS), deviceId must match a UDID in the project's registered devices for the device to see it — send the real device UDID as deviceId if you use that mode; either way, a device that doesn't qualify keeps getting the previous published release; omit deviceId to always get the latest, ignoring both). Returns { updateAvailable: false } if nothing newer, or { updateAvailable: true, latestVersion, latestBuildNumber, notes, updateUrl } — updateUrl is an itms-services:// link for iOS, a direct APK download for Android, or the app's own URL for web.
curl "https://your-app/api/v1/check-update?platform=ios¤tVersion=1.2.0" \ -H "Authorization: Bearer qap_..."
/api/public/crash-reportReport a caught exception from a distributed app. No auth token — a release id is unguessable, same trust model as the tester feedback endpoint. Required: releaseId, exceptionType. Optional: message, stackTrace, deviceModel, osVersion, deviceName, osName (falls back to a User-Agent parse when omitted, same as report-issue), networkType (wifi|cellular|none), wifiSignalStrength (RSSI in dBm — Android-only; iOS has no public API for real signal strength, Apple removed it, so this is always omitted there and on web). Reports are grouped by exceptionType + the stack trace's first line — no automatic symbolication, so send a human-readable stack (e.g. a JS Error.stack, or your own de-obfuscated trace) rather than raw addresses if you want it to mean anything on the Crashes tab. The Capacitor plugin's enableAutoCrashDetection() (and the 'auto-capturing crashes' sections in sdk/native-examples) wires window.onerror/unhandledrejection or a Thread default handler so crashes reach this endpoint automatically instead of being wrapped by hand.
fetch("https://your-app/api/public/crash-report", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
releaseId: "<release-id>",
exceptionType: error.name,
message: error.message,
stackTrace: error.stack,
osName: Platform.OS,
osVersion: Platform.Version?.toString(),
// networkType/wifiSignalStrength: auto-filled by the Capacitor plugin
// and native SDK snippets from platform APIs — a bare fetch() like this
// would need e.g. @react-native-community/netinfo to supply networkType.
}),
});/api/public/report-issueSend a tester bug report from a distributed app — the in-app equivalent of the web share page's 'Report an issue' form, called by the SDK's sendFeedback(). Reports land in the project's bug-report triage inbox (Bugs tab), where a developer can promote one onto the kanban board. No auth token — a release id is unguessable, same trust model as crash-report. Required: releaseId and either feedback or title. Optional: title, description (alias of feedback, sent by the web form), moduleScreen, stepsToReproduce, expectedResult, actualResult, appVersion, reporterName, reporterEmail, deviceModel, osName, osVersion — when the device/OS fields are omitted they're parsed from the request's User-Agent instead (meaningful for a web caller, not a native one).
fetch("https://your-app/api/public/report-issue", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
releaseId: "<release-id>",
title: "Login button does nothing on iPad",
feedback: "Tapping Login on the iPad does nothing — no error, no navigation.",
moduleScreen: "Login",
stepsToReproduce: "1. Open app\n2. Tap Login\n3. Nothing happens",
expectedResult: "Navigates to the dashboard",
actualResult: "Button stays unresponsive",
reporterName: "Jane Doe",
reporterEmail: "jane@example.com",
osName: Platform.OS,
osVersion: Platform.Version?.toString(),
}),
});/api/public/install-receiptConfirm an install from a distributed app — called by the SDK's confirmInstall() on first launch after a successful install. This is what lets analytics distinguish confirmed installs from install clicks (clicks are counted on the manifest/download redirect and can be inflated by aborted downloads; a receipt proves the app actually ran). No auth token — a release id is unguessable, same trust model as crash-report. Required: releaseId. Optional: platform-derived deviceModel, osName, osVersion, appVersion, firstLaunchAt (the app's own launch time), deviceId (a stable per-device id, used only for rate limiting). Best-effort and fire-and-forget — the app should never block startup on this.
fetch("https://your-app/api/public/install-receipt", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
releaseId: "<release-id>",
deviceModel: Device.model,
osVersion: Platform.Version?.toString(),
appVersion: appVersion,
}),
});/api/public/register-push-tokenRegister a device's FCM token so it receives a native push notification the moment a new release publishes on its channel — called by the SDK's registerPushToken(). No auth token — a release id is unguessable, same trust model as crash-report/install-receipt. Required: releaseId, deviceId, platform (ios or android), token. Optional: channel (defaults to the release's own channel). This endpoint only relays a token already obtained from Firebase's own SDK — it doesn't request notification permission or fetch a token itself. Fire-and-forget; call it once you have a token, and again whenever Firebase reissues one.
fetch("https://your-app/api/public/register-push-token", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
releaseId: "<release-id>",
deviceId: deviceId,
platform: Platform.OS,
token: fcmToken,
}),
});To show a "New version available" prompt inside a distributed app: call check-update on launch, and if updateAvailable is true, confirm with the user and open updateUrl — that's the whole flow, no SDK needed. On iOS it triggers the native OTA install prompt; on Android it downloads the APK and the OS offers to install it.
// React Native, called once on app launch
const res = await fetch(
`https://your-app/api/v1/check-update?platform=${Platform.OS}¤tVersion=${appVersion}`,
{ headers: { Authorization: "Bearer qap_..." } }
);
const data = await res.json();
if (data.updateAvailable) {
Alert.alert(
"Update available",
`Version ${data.latestVersion} is ready. Update now?`,
[
{ text: "Later", style: "cancel" },
{ text: "Yes", onPress: () => Linking.openURL(data.updateUrl) },
]
);
}Both calls above are plain HTTP — no SDK is required for either. If you'd rather not wire up the requests yourself, this repo's sdk/ directory has a starting point for common stacks:
@qa-platform/capacitor-plugin— a real plugin with web, Android (Kotlin), and iOS (Swift) implementations. See sdk/capacitor-plugin.