canonical: https://jentic.com/apis/appskyline.com/appskyline

# AppSkyline API

The AppSkyline API tracks apps and keywords for app store optimization and reports how they rank. It lists and manages the apps and keywords in a workspace, reads Apple App Store engagement rows, and runs rank checks that a caller can poll for results. A batch endpoint reads several collections in one request, webhook subscriptions deliver rank updates, and a set of unauthenticated sandbox endpoints lets a caller try rank checks before wiring credentials.

## For AI agents

Track apps and keywords for ASO and read how they rank: manage apps and keywords, read App Store engagement rows, run rank checks, and subscribe to rank-update webhooks. Authenticate with HTTP Basic or an access token; sandbox endpoints are open.

## Scope

Does not submit apps to the stores, run ad campaigns, or manage store listings. Use for tracking apps and keywords and reading their ranks only.

## Capabilities

- Track apps in a workspace and read their App Store engagement rows
- Add, update, and remove the keywords tracked for an app
- Read Apple App Store engagement data for tracked apps
- Start a rank check in the sandbox and poll it for results
- Group several collection reads into one batch request
- Register webhook subscriptions that deliver rank updates

## Use cases

### Keyword Rank Tracking

An agent maintains a set of tracked keywords for an app and reads their rank over time to guide optimization. AppSkyline lets the agent add keywords, poll rank checks, and subscribe to webhooks so rank movements arrive without constant polling, keeping an ASO dashboard current.

Example prompt: Call POST `/api/keywords` to track a term, then GET `/api/keywords` to read its tracked rank for the app

### App Portfolio Monitoring

A monitoring workflow lists the apps in a workspace and reads their Apple App Store engagement rows, grouping several collection reads into one batch call. The agent pulls engagement and keyword data per app so a portfolio view stays up to date without separate requests for each resource.

Example prompt: Call GET `/api/apps` to list the workspace apps, then POST `/api/batch` to read their engagement rows in one request

### AI Agent Integration via Jentic

An AI agent reaches the AppSkyline API through Jentic without handling the Basic credential itself. It searches by intent, receives the matching operation with its input schema, and executes the call with the credential injected at run time, so keyword tracking and rank reads become steps in a larger ASO workflow.

Example prompt: Search Jentic for 'track an app keyword', load the POST `/api/keywords` schema, and execute it with Jentic-managed credentials

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/api/apps` | List tracked apps |
| POST | `/api/apps` | Create a tracked app |
| GET | `/api/keywords` | List tracked keywords |
| POST | `/api/keywords` | Add a tracked keyword |
| GET | `/api/apple-app-store-engagement` | Read Apple App Store engagement rows |
| POST | `/api/batch` | Read multiple collections in one request |
| POST | `/api/webhooksubscriptions` | Create a webhook subscription |
| GET | `/api/sandbox/keywords` | Read sandbox keyword ranks without authentication |

## Key resources

- **Apps** — List, create, and read tracked apps via `/api/apps` and `/api/apps/{appId}`
- **Keywords** — Add, update, and remove tracked keywords via `/api/keywords` and `/api/keywords/{keywordId}`
- **Rank Checks and Webhooks** — Run sandbox rank checks and manage rank-update webhooks via `/api/sandbox/rankchecks` and `/api/webhooksubscriptions`

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 60 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 81 / 100
  - Developer Experience & Jentic Compatibility: 61 / 100
  - AI-Readiness & Agent Experience: 54 / 100
  - Agent Usability: 94 / 100
  - Security: 30 / 100
  - AI Discoverability: 75 / 100
- **View full report:** https://jentic.com/apis/appskyline.com/appskyline/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring AppSkyline by hand means base64-encoding your key secret for Basic auth, or managing an access token, and tracking per-resource scopes yourself. Through Jentic you install once, import AppSkyline from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** AppSkyline carries the app and keyword ids inside each request, so a rule bounds which operations your agent may call. You choose the operations it may use, such as the read and sandbox rank-check operations, so the create, update, and delete operations are not included unless you add them.
- **Credential handling:** Your AppSkyline credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'track an app keyword' or 'read app engagement rows', and Jentic returns the matching AppSkyline operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **appmanai Public API** — App Store and Google Play metrics and keyword data for ASO
- **Semrush** — Web search keyword research and competitive SEO data
- **Ahrefs** — Backlink and keyword data for web SEO

## FAQ

### What authentication does the AppSkyline API use?

The AppSkyline API authenticates with HTTP Basic auth using a base64-encoded key secret, or with an access token in the Authorization header, per its OpenAPI spec, and keys carry per-resource scopes such as keywords:read or apps:write. The three sandbox endpoints need no credential. Through Jentic the credential is stored encrypted by your own Jentic One instance and injected at execution time, so it never reaches the agent.

### Can I track keyword rankings for an app with the AppSkyline API?

Yes. POST `/api/keywords` adds a keyword to track for an app, GET `/api/keywords` lists the tracked keywords, and the sandbox rank-check endpoints let you try a rank check before wiring credentials. Webhook subscriptions deliver rank updates so you do not have to poll continuously.

### What are the rate limits for the AppSkyline API?

The AppSkyline OpenAPI spec does not specify rate limits. Watch for HTTP 429 responses and check AppSkyline's documentation for the current limits before running large batches of rank checks.

### How do I track an app keyword with the AppSkyline API through Jentic?

Search Jentic for 'track an app keyword', and it returns the AppSkyline operation with its input schema. Load the schema and execute POST `/api/keywords` with the credential injected at run time. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Is there an AppSkyline MCP server?

You don't need an MCP server to give your agent the AppSkyline API. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls the tracking and rank operations it needs. Operations are discovered on demand, so no extra server's tool definitions sit in the agent's context.

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

Yes. Write a rule that allows only the read operations and the sandbox rank checks, so the agent can list apps and read ranks while the create, update, and delete operations stay off the table. Keys also carry per-resource scopes, and every call runs through your own instance where it is logged for review.