canonical: https://jentic.com/apis/appcenter.ms/appcenter

# Microsoft Azure App Center Client

The Microsoft Visual Studio App Center API gives mobile DevOps teams programmatic access to App Center's build, test, distribute, codepush, crash, analytics, and account management surfaces. The 351 endpoints cover app provisioning, release distribution, crash group inspection, audience analytics, in-app event logs, and team membership so end-to-end mobile delivery can run from external tooling. Authentication accepts an X-API-Token header or HTTP basic, and the API is organised around the {owner_name}/{app_name} addressing scheme.

## For AI agents

Manage App Center mobile app builds, releases, crash groups, analytics audiences, and codepush deployments so an agent can drive a mobile DevOps pipeline from outside the App Center UI.

## Scope

Does not handle source-code hosting, app-store submission, or in-app purchase processing - use for App Center build, distribute, crash, analytics, and CodePush operations only.

## Capabilities

- Trigger and inspect builds for an app via the build endpoint family
- Distribute releases to testers and groups through the distribute endpoints
- Inspect crash groups and crash counts to triage stability issues
- Run analytics queries on active devices, audiences, and event logs
- Push CodePush releases to live mobile apps without app-store re-review
- Manage API tokens, organizations, and apps through the account endpoints
- Export GDPR data and crash exports for compliance reporting

## Use cases

### Mobile Crash Triage Automation

Detect rising mobile crash rates and route them to engineering automatically by walking `/v0.1/apps/{owner}/{app}/analytics/crash_groups` and `/v0.1/apps/{owner}/{app}/analytics/crash_counts.` The agent compares the current 24-hour count to a rolling baseline and opens a Shortcut or Linear story for the on-call engineer when the threshold is breached, removing the manual dashboard sweep.

Example prompt: List crash groups via GET `/v0.1/apps/{owner}/{app}/analytics/crash_groups`, fetch counts for each, and open a story for any group whose 24-hour count exceeds the rolling average by 50 percent

### CodePush Release Orchestration

Push hotfix bundles to live mobile apps without going through app-store review by automating CodePush releases through the codepush endpoint family. The agent pairs the CodePush deployment call with crashfree-percentages monitoring so that if crashfree drops after a release, the agent can roll back automatically - turning CodePush into a safer release channel.

Example prompt: Push a CodePush release through the codepush deployment endpoint, then poll `/v0.1/apps/{owner}/{app}/analytics/crashfree_device_percentages` and roll back if crashfree drops below 99 percent

### Tester Group Distribution

Distribute new releases to specific tester groups by combining the distribute endpoint with `/v0.1/apps/{owner}/{app}/analytics/audiences` for targeted rollouts. This is the typical pattern when releasing a beta to power-users in one country before a global rollout, and the agent can use the audience metadata endpoints to confirm the target population before pushing.

Example prompt: Look up the target audience via `/v0.1/apps/{owner}/{app}/analytics/audiences/{audience_name}`, then trigger a distribution to that audience via the distribute endpoint

### GDPR Export Automation

Honour data-subject access requests by triggering `/v0.1/account/test/export` and the related GDPR endpoints to produce per-account exports. The agent assembles the resulting export package, posts it to the requesting user's secure channel, and records the request in an audit log, removing the manual export-and-zip work from the privacy team.

Example prompt: Call POST `/v0.1/account/test/export` with the account identifier, monitor the export status, and deliver the resulting bundle to the privacy team's secure store

### Agent-Driven Mobile DevOps

Let an AI assistant answer mobile DevOps questions like 'is the iOS app crashing more this week?' by exposing App Center analytics through Jentic. The agent searches for the right operation, loads its schema, and executes - never holding the X-API-Token, which carries broad write access across the App Center org.

Example prompt: Search Jentic for 'list crash counts for an app', load the schema for `/v0.1/apps/{owner}/{app}/analytics/crash_counts`, and execute against the named app

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v0.1/apps` | List apps for the account |
| GET | `/v0.1/apps/{owner_name}/{app_name}` | Fetch a specific app |
| GET | `/v0.1/apps/{owner_name}/{app_name}/analytics/crash_groups` | List crash groups for an app |
| GET | `/v0.1/apps/{owner_name}/{app_name}/analytics/active_device_counts` | Pull active device counts |
| GET | `/v0.1/apps/{owner_name}/{app_name}/analytics/crashfree_device_percentages` | Get crashfree percentages |
| GET | `/v0.1/apps/{owner_name}/{app_name}/analytics/audiences` | List audience definitions |
| GET | `/v0.1/api_tokens` | List API tokens for the account |

## Key resources

- **Account** — Manage API tokens, administered organizations, and account-level exports
- **Apps** — Provision and manage apps under an owner
- **Build** — Trigger and inspect builds for an app
- **Distribute** — Manage release distribution to testers and groups
- **Crash** — Inspect crash groups, counts, and overall stability metrics
- **Analytics** — Query active devices, audiences, event logs, and crashfree percentages
- **CodePush** — Push over-the-air bundles to React Native and Cordova apps

## Why Jentic

- **Setup:** Wiring App Center by hand means managing its X-API-Token header alongside basic auth and navigating a large build, distribute, crash, and analytics surface yourself. Through Jentic you install once, import the App Center API from the API Directory, store the credentials once, and your agent calls it.
- **Permission scoping:** App Center puts owner_name and app_name in the URL path (`/v0.1/apps/{owner_name}/{app_name}/...`), so a rule can pin your agent to one app's analytics and crash groups. You choose the operations it may call, so account-wide reads like listing API tokens are not included unless you add them.
- **Credential handling:** Your App Center API token and basic credentials are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'list crash groups' or 'get active device counts', and Jentic returns the matching App Center operation with its input schema so the agent calls the right endpoint without navigating the full endpoint surface up front.

## Related APIs

- **Firebase API** — Firebase covers mobile crash, analytics, and remote config from the Google ecosystem
- **Sentry API** — Sentry focuses on crash and error monitoring across mobile, web, and backend
- **Bugsnag API** — Bugsnag specialises in stability monitoring and release health across platforms
- **Rollbar API** — Rollbar covers error monitoring and triage across web and mobile

## FAQ

### What authentication does the App Center API use?

Two schemes are supported: an X-API-Token header (preferred for service-to-service calls) and HTTP basic auth. Through Jentic the X-API-Token is stored encrypted in the vault (your Jentic One instance) and never enters agent context - agents receive scoped access only.

### Can I push a CodePush release with this API?

Yes. The codepush endpoint family covers deployment creation, release upload, and rollback. Combine it with `/v0.1/apps/{owner}/{app}/analytics/crashfree_device_percentages` to monitor stability after the release lands.

### What are the rate limits for the App Center API?

The OpenAPI spec does not encode explicit rate limits. App Center applies per-token throttling that returns HTTP 429 when exceeded - inspect response headers for live state and back off before retrying.

### How do I check crash counts through Jentic?

Run pip install jentic, then search 'list app center crash counts'. Jentic returns the `/v0.1/apps/{owner}/{app}/analytics/crash_counts` operation with its input schema - load the schema, populate owner and app, and execute. The agent never sees the X-API-Token.

### How does the {owner_name}/{app_name} addressing work?

Most app-scoped endpoints take the owner (organization or user) and app name as path parameters. List your apps via GET `/v0.1/apps` to find the correct values, and prefer using the canonical owner_name shown there to avoid casing mismatches.

### Can I run GDPR data exports through this API?

Yes. POST `/v0.1/account/test/export` and the surrounding GDPR endpoints generate per-account export bundles. Use these for data-subject access request automation rather than manual exports from the App Center portal.

### Can I limit what my agent is allowed to do with the App Center API?

Yes. Because you run Jentic One yourself, your own rules decide which App Center operations and credentials the agent may use. Since App Center puts owner_name and app_name in the URL path (`/v0.1/apps/{owner_name}/{app_name}/...`), you can pin the agent to a single app's analytics and crash group reads, such as GET `/v0.1/apps/{owner_name}/{app_name}/analytics/crash_groups.` You choose the operations it may call, so account-wide actions like listing API tokens stay excluded unless you add them.