Submit a Fire TV app to the Amazon Appstore from the CLI

A Fire TV app built on Fire OS is an Android app, and VibeView treats it as an Android TV app: you build it, test it and submit it as androidtv. The Amazon Appstore is a second store for those builds, next to Google Play. The same command also takes Fire tablet apps, which you build and submit as android.

Amazon ended the Appstore on other Android devices on 20 August 2025, and it continues on Fire TV, Fire tablets and TVs with Fire TV built in (Amazon’s announcement). Fire TV apps built for Vega OS are not supported.

What Amazon’s API does and doesn’t do

VibeView submits through Amazon’s App Submission API, so its limits are yours too. Amazon’s App Submission API overview says:

It updates existing apps only. The first version of an app must be submitted in the Amazon Developer Console.
It takes .apk files, not Android App Bundles (.aab).
One open edit per app. An edit is Amazon’s container for a new version; only one can be open at a time.
It can’t create or update a Live App Testing version. Testing with invited testers stays in the console.
Some fields are console-only, among them content rating, availability and pricing.

VibeView adds one limit of its own: it submits an .apk of up to 300 MB. A larger one is refused before anything is sent to Amazon, so upload it in the Developer Console instead.

Test it before you submit

The signed .apk you submit is a production build: you download it or send it to a store, but it can’t run on a VibeView device. To test first, open a development or preview build of the same code in a browser. Fire OS apps run on VibeView’s Android TV emulators, so you can drive the app with the D-pad and run your test groups on it before Amazon sees it.

Two things differ from a Fire TV device. The emulator identifies itself as an Android TV device, so an app that checks for Fire TV takes its Android TV code path. And Amazon services (the Appstore, in-app purchasing, Amazon Device Messaging, Login with Amazon, Alexa) are not available. Fire TV (Fire OS) apps has the details, and the smart TV testing checklist lists what to check on any TV app.

One-time setup

Submit the app’s first version by hand. Create the app in the Amazon Developer Console and submit its first version there. This is the only part that can’t be done from the CLI. From then on, the API can update it.
Create an API key. Amazon’s API key is a security profile: a client ID and client secret that let a tool use the App Submission API for your account. An account with Admin credentials opens My Settings → API Access in the Amazon Developer Console and creates a security profile for the App Submission API. It notes the client ID and client secret from the profile’s Web Settings tab, then attaches the profile to the API. Amazon’s authentication guide has the full steps.
Store the key in VibeView. On the Builds page, open Stores → Amazon Appstore keys → Add key, or run:
```
vibeview credentials amazon-key add --client-id <client-id>
```
The CLI prompts for the secret with hidden input (or reads it from stdin when piped); it is never a flag. VibeView checks the key with Amazon before saving it, and you can’t read it back afterwards. Adding and removing keys needs the Admin role in VibeView. vibeview credentials amazon-key test amazon asks Amazon whether it still accepts the key.
Find the App ID. In the Developer Console, open the app, then Upload Your App File → Additional information → App ID. It starts with amzn1.devportal.mobileapp.. You pass it once; VibeView saves it on the app.

Add an amazon build profile. Google Play takes an .aab, but Amazon’s submission API, which VibeView uses, takes only an .apk, so keep production for Play and add a second signed profile that runs assembleRelease. For an Expo app:

{
  "platforms": {
    "androidtv": {
      "appId": "app_abc123",
      "build": {
        "profiles": {
          "production": {
            "command": "npm ci && npx expo prebuild --platform android --no-install && cd android && ./gradlew bundleRelease",
            "artifact": "android/app/build/outputs/bundle/release/*.aab"
          },
          "amazon": {
            "command": "npm ci && npx expo prebuild --platform android --no-install && cd android && ./gradlew assembleRelease",
            "artifact": "android/app/build/outputs/apk/release/*.apk",
            "distribution": "production",
            "autoIncrement": true
          }
        }
      }
    }
  }
}

"distribution": "production" makes it a signed build, with the same Android keystore your Play builds use; one keystore covers phone and TV builds (App signing). Without it, the profile builds for the emulator, and --latest won’t find it. For a React Native, Flutter or native project, use the command that produces your release .apk.

Check that Amazon knows the app. No build needed:
```
vibeview submit --check --platform androidtv --store amazon --amazon-app-id amzn1.devportal.mobileapp.<id>
```
It exits 0 when Amazon knows the app with your stored key, and says so when an edit is already open in the Developer Console.

Build and submit

Build the .apk:

vibeview build --cloud --platform androidtv --profile amazon

Submit it:
```
vibeview submit --platform androidtv --store amazon --latest \
  --release-notes "Faster channel guide and bug fixes"
```
The first time, add --amazon-app-id <id>; later submissions of the app can leave it out. With --store amazon, --latest picks the newest production .apk build. --release-notes (or --release-notes-file) is required and goes to every language your Amazon listing has. --notes-dir doesn’t apply: Amazon gets one note for all languages.
Wait for Amazon’s review. VibeView uploads the .apk, writes the notes and sends the version for Amazon review. Amazon publishes it once review passes. Follow the review in the Amazon Developer Console, under My Apps → your app. In VibeView, the submission shows as Sent for Amazon review on the Submissions tab of the Builds page, with its upload log on the build’s Store submissions card.

From the dashboard, open Submit to store on the build, choose Amazon Appstore under Store, fill in the Amazon App ID (already filled once saved) and Release notes (Reuse last notes copies the last ones), and choose Submit for review. The button stays off until Amazon knows the app and the notes are written.

Version codes

Amazon accepts a new version only when its versionCode is higher than the live version’s. There is no separate Amazon counter: with "autoIncrement": true on the profile, an amazon build takes the next number from the same per-app, per-platform counter as your Google Play builds. The number reaches your build as the VIBEVIEW_BUILD_NUMBER environment variable. Wire it into versionCode once (in Expo’s app.config.js, or in android/app/build.gradle), as Automatic build numbers shows.

If Amazon refuses the number, raise the counter in Builds → Stores → your app → Edit → Build number (on the Google Play row), or with vibeview versions set <number> --app <app-id> --platform androidtv (the next build gets the number plus one), and rebuild.

Open edits and review

Amazon allows one pending edit per app. If someone started changes in the Amazon Developer Console, the submission stops and says so instead of throwing those changes away. Finish or delete the edit there, or pass --discard-open-edit to discard it (in the dialog, tick Discard the open edit in the Amazon Developer Console, which only shows when one is open). An edit left behind by an earlier VibeView submission that failed is removed automatically.

While a version is in Amazon review, the app can’t be updated: a new submission is refused until the review finishes or you cancel it in the Developer Console. Only one Amazon submission per app runs at a time.

Testers before release

Amazon offers no test tracks through its API, so every VibeView submission goes to review. To get a build to testers first, download its .apk from the Builds page or with vibeview builds download <id>, and upload it to Live App Testing in the Amazon Developer Console. Amazon’s Live App Testing guide explains how it works.

In CI

A CI-only VibeView token can submit to the Amazon Appstore with the key already stored in VibeView, so the same two commands run in a pipeline. Pass --build <id> instead of --latest so each run submits its own build. Think twice before adding --discard-open-edit in CI: it lets the pipeline throw away an edit someone left open in the Amazon Developer Console. GitHub Actions to TestFlight shows a full workflow and the lines that change for Amazon.

Common refusals

Message	What to do
Amazon doesn’t know this App ID	Check the App ID. The app’s first version must be submitted in the Amazon Developer Console
Amazon refused the credentials	Check the client ID and secret, and that the security profile is attached to the App Submission API
Add your app’s Amazon App ID	Pass `--amazon-app-id`, or type it in the dialog’s Amazon App ID field
Amazon’s API accepts only .apk files	Build with the `amazon` profile above, or upload the `.aab` in the Developer Console
This APK is over 300 MB, which VibeView can’t submit to Amazon yet	Upload it in the Developer Console
An edit is already open in the Amazon Developer Console	Finish or delete it there, or submit again with `--discard-open-edit`
This app is in Amazon review	Wait for the review to finish, or cancel it in the Developer Console
This Amazon app has no store listing to write release notes to	Add a listing in the Developer Console
VibeView can only update an Amazon app that has exactly one binary	Upload in the Developer Console
A versionCode refusal from Amazon	Raise the build number counter and rebuild (see Version codes)

Every refusal, for every store, is in Common refusals.

What stays in the Amazon Developer Console

The first version of an app, the store listing (My Apps → your app → Appstore Details), Live App Testing, content rating, pricing and availability, and following the review. Done in the store’s console lists where each task lives for every store.

Shipping to the other TV stores

The same CLI sends Apple TV builds to TestFlight (--platform tvos; see Build an Apple TV app without a Mac) and Android TV builds to Google Play (--platform androidtv without --store amazon). Roku channels are tested and shared on a cloud Roku in VibeView, but publishing a channel to Roku’s Streaming Store stays in Roku’s Developer Dashboard.

Next: run vibeview submit --check --platform androidtv --store amazon with your App ID, then build the amazon profile and submit it.

Frequently asked questions

Can I submit an .aab to the Amazon Appstore?

Not through Amazon’s API, so not through VibeView. Build an .apk with a second profile, or upload the .aab in the Amazon Developer Console yourself.

Can VibeView create my app on the Amazon Appstore?

No. Amazon’s API can only update an app that exists, so the first version goes through the Developer Console. Every version after that can come from the CLI.

Does VibeView have Fire TV devices?

No. Fire OS apps run on Android TV emulators in VibeView. The app works as it does on Android TV, without Amazon’s own services, and it sees an Android TV device rather than a Fire TV.

Can I send a build to Live App Testing from the CLI?

No. Amazon’s API doesn’t support Live App Testing versions. Download the .apk and upload it to Live App Testing in the Developer Console.

Does the same build go to Google Play?

The same code and keystore do, but usually not the same file: Google Play takes the .aab from the production profile, and Amazon the .apk from the amazon profile. Both take version codes from the same counter.

Amazon’s pages quoted here were checked on 25 October 2026.