fastlane-plugin-galaxystore

A fastlane plugin for managing Android app releases on the Samsung Galaxy Store using the Galaxy Store Developer API.

• Getting Started
  • Prerequisites
  • Installation
  • Authentication
• Actions
• App status lifecycle
• Example Workflows
• Issues and Feedback
• Troubleshooting
• About fastlane

Before using this plugin you will need:

1. A Samsung Galaxy Store seller account at seller.samsungapps.com
2. A service account and access token, created via Assistance → API Service in the seller portal
3. The 12-digit content ID for your app (visible in the Galaxy Store seller portal)

Add the plugin to your project:

fastlane add_plugin galaxystore

Or add it manually to your fastlane/Pluginfile:

gem 'fastlane-plugin-galaxystore'

Then run bundle install.

The plugin requires two credentials for all API calls. Set them as environment variables and the plugin will read them automatically, you don't need to pass access_token or service_account_id to individual actions:

export GALAXY_STORE_ACCESS_TOKEN="your-access-token"
export GALAXY_STORE_SERVICE_ACCOUNT_ID="your-service-account-id"

The examples below assume these environment variables are set. If you need to pass credentials explicitly (e.g. from a CI secret store), every action accepts access_token: and service_account_id: params that override the environment.

Imports app metadata from a Supply (Google Play) metadata directory into the Galaxy Store format. Use this action to populate fastlane/metadata/galaxystore/ from an existing fastlane/metadata/android/ directory, so you can reuse Play Store content for your Galaxy Store listing.

The action:

• Maps BCP-47 language codes (used by Supply) to Galaxy Store language codes
• Copies title.txt, short_description.txt, and full_description.txt → long_description.txt for each language
• Copies phone screenshots from each language's phoneScreenshots/ directory
• Copies a changelogs/ file as <galaxy_code>/new_feature.txt per language. When version_code is set, looks for changelogs/<version_code>.txt and falls back to changelogs/default.txt. When version_code is omitted, uses default.txt only
• Copies icon.png from the default language's directory to the top-level galaxystore/ folder
• Copies the default language's video.txt to top-level youtube_url.txt
• Optionally copies the default language's featureGraphic to top-level hero_image.png (Game-category apps only — see import_hero_image below)
• When multiple regional variants of a language exist (e.g. es, es-ES, es-419), selects the best one automatically with a warning

galaxy_store_import_from_supply(
  default_language_code: "ENG"
)

Resolving language variant conflicts with language_priority:

If your Supply metadata contains multiple variants for the same language (e.g. both es-ES and es-419), the action picks one automatically. Use language_priority to control which variant is used for a specific Galaxy Store language code:

galaxy_store_import_from_supply(
  language_priority: {
    "SPA" => "es-419",
    "POR" => "pt-BR"
  }
)

Returns: A hash mapping Galaxy Store language codes to the BCP-47 directories they were imported from.

Note: Galaxy Store only supports one app icon, one YouTube URL, and one hero image. They are taken from the default_language_code language's Supply directory. If that language is not present in the Supply metadata, those app-level files will not be copied.

Retrieves detailed information for a specific app and writes the metadata to local files in fastlane/metadata/galaxystore/. Prefers any in-progress listing (any contentStatus other than FOR_SALE) if one exists, otherwise falls back to the FOR_SALE listing. See App status lifecycle for the statuses you'll typically see.

Warning: This action deletes and recreates the entire fastlane/metadata/galaxystore/ directory, including hero_image, youtube_url.txt, any local edits, and anything imported from Supply by galaxy_store_import_from_supply.

The following files are written for each supported language:

fastlane/metadata/galaxystore/
  icon.png
  hero_image.png       # only when the listing has one (Game-category apps)
  youtube_url.txt      # only when the listing has a YouTube URL set
  app_info.json        # raw contentInfo API response
  ENG/
    title.txt
    short_description.txt
    long_description.txt
    new_feature.txt    # release notes; only when the listing has them
    screenshots/
      1.png
      2.png
      ...
  FRA/
    title.txt
    ...

galaxy_store_app_info(
  content_id: "000007654321"
)

Returns: An array of listing hashes (the raw contentInfo API response), typically one per contentStatus.

Reads app metadata from the local fastlane/metadata/galaxystore/ directory, uploads any image assets (icon and screenshots), and submits everything to the Galaxy Store via the content update API.

galaxy_store_upload_metadata(
  content_id: "000007654321"
)

The action scans the galaxystore/ directory for:

• icon.png (or other image extension) at the top level
• hero_image.png at the top level (uploaded only when upload_hero_image: true)
• youtube_url.txt at the top level
• title.txt, short_description.txt, long_description.txt, new_feature.txt in each language directory
• Images in each language's screenshots/ subdirectory

Only languages and fields that exist on disk are included in the update payload.

Note: The Galaxy Store API exposes additional listing fields (support email, privacy policy URL, copyright holder, age limits, categories, etc.) that this action does not touch — manage them through the Galaxy Store seller portal. The local directory format is additive-only: new top-level files or per-language files for these fields can be added in future releases without breaking existing setups.

Returns: A hash containing the content update API response.

Retrieves the full list of apps registered to your Galaxy Store seller account.

app_list = galaxy_store_app_list

# Optionally write the result to a JSON file
galaxy_store_app_list(
  output_path: "app_list.json"
)

Returns: An array of hashes, each containing app information for a registered app.

Uploads an APK or AAB file to the Galaxy Store. This action handles the full upload flow automatically:

1. Opens an update draft for the app (contentUpdate)
2. Creates an upload session ID
3. Uploads the binary file
4. Registers the binary against the content ID (add binary)

galaxy_store_upload_apk(
  content_id: "000007654321",
  apk_path: "app/build/outputs/apk/release/app-release.apk",
  gms: "N"
)

Returns: The binarySeq (string) of the newly added binary, or nil if the API did not include one.

Lane context: Sets SharedValues::GALAXY_STORE_BINARY_SEQ to the same value, so galaxy_store_update_staged_rollout_binary can pick it up automatically when chained.

Configures how and when an app update goes live after passing review. Must be called before galaxy_store_submit_app. Defaults to automatic publication ('01') if publication_type is not specified.

# Automatic (default)
galaxy_store_set_publication_type(
  content_id: "000007654321",
  publication_type: "01"
)

# Scheduled date
galaxy_store_set_publication_type(
  content_id: "000007654321",
  publication_type: "02",
  start_publication_date: "2026-06-01 09:00:00"
)

# Manual — publisher controls when the update goes live
galaxy_store_set_publication_type(
  content_id: "000007654321",
  publication_type: "03"
)

*Required when publication_type is '02'.

Returns: A hash containing the content update API response.

Submits a pending app update for review. Can be used standalone after making changes in the seller portal, or chained after galaxy_store_upload_apk or galaxy_store_upload_metadata.

galaxy_store_submit_app(
  content_id: "000007654321"
)

Returns: A hash containing the submission API response.

Sets the app status to FOR_SALE, making it live on the Galaxy Store. Intended for use after galaxy_store_submit_app when the app was submitted with the Manual Publication option ('03'), allowing the publisher to control exactly when the update goes live.

galaxy_store_publish_app(
  content_id: "000007654321"
)

Returns: A hash containing the content status update API response.

Adds or removes a binary from the staged rollout group for a given app. Use galaxy_store_staged_rollout first to view available binaries and their binarySeq values, or chain directly after galaxy_store_upload_apk and the seq will be picked up from lane context automatically.

# Chain directly after upload — binary_seq picked up from lane context
galaxy_store_upload_apk(
  content_id: "000007654321",
  apk_path: options[:apk_path],
  gms: "N"
)
galaxy_store_update_staged_rollout_binary(
  content_id: "000007654321",
  function: "ADD"
)

# Or specify binary_seq explicitly
galaxy_store_update_staged_rollout_binary(
  content_id: "000007654321",
  function: "REMOVE",
  binary_seq: "15"
)

Returns: A hash containing the staged rollout binary API response.

Enables or disables the staged rollout rate for a given app. Supports a global rollout rate, per-country rates hardcoded in the Fastfile, or a JSON file for complex per-country configurations.

Enable with a global rate:

galaxy_store_set_staged_rollout(
  content_id: "000007654321",
  action: "ENABLE",
  app_status: "REGISTRATION",
  rollout_rate: 25
)

Enable with per-country rates hardcoded in the Fastfile:

galaxy_store_set_staged_rollout(
  content_id: "000007654321",
  action: "ENABLE",
  app_status: "REGISTRATION",
  rollout_rate: 25,
  countries: [
    { countryCode: "USA", rolloutRate: 40 },
    { countryCode: "KOR", rolloutRate: 45 }
  ]
)

Enable with per-country rates from a JSON file:

galaxy_store_set_staged_rollout(
  content_id: "000007654321",
  action: "ENABLE",
  app_status: "REGISTRATION",
  rollout_rate: 25,
  countries_json_path: "fastlane/rollout_countries.json"
)

Where rollout_countries.json contains:

[
  { "countryCode": "USA", "rolloutRate": 40 },
  { "countryCode": "KOR", "rolloutRate": 45 }
]

Disable staged rollout:

galaxy_store_set_staged_rollout(
  content_id: "000007654321",
  action: "DISABLE",
  app_status: "REGISTRATION"
)

*Required when action is ENABLE.

Returns: A hash containing the staged rollout rate API response.

Checks which binaries have staged rollout enabled for a given app, and if any are found, also retrieves the current rollout rate.

galaxy_store_staged_rollout(
  content_id: "000007654321",
  app_status: "SALE" # or "REGISTRATION"
)

Returns: A hash with symbol keys :binaries (array of binary info) and :rollout_rate (rate data, or nil if rollout is not enabled). Returns nil when no binaries are registered for the given app_status.

Each listing returned by galaxy_store_app_info has a contentStatus field that reflects where it sits in the Galaxy Store publication flow. Common values:

Samsung's review pipeline includes additional intermediate states we may not have documented yet. The galaxy_store_app_info action handles this by treating any contentStatus other than FOR_SALE as in-progress, so new statuses are picked up automatically. A rejected submission returns to REGISTERING or UPDATING rather than producing a distinct rejected status — check the seller portal for review feedback.

After galaxy_store_submit_app with manual publication ('03'), poll galaxy_store_app_info and call galaxy_store_publish_app once the in-progress listing reaches READY_FOR_CHANGE:

lane :publish_when_ready do
  info = galaxy_store_app_info(content_id: "000007654321")
  ready = info.any? { |entry| entry['contentStatus'] == 'READY_FOR_CHANGE' }
  if ready
    galaxy_store_publish_app(content_id: "000007654321")
  else
    UI.message("Not yet approved — try again later")
  end
end

Upload a new binary and submit it for review in a single lane:

lane :release do |options|
  galaxy_store_upload_apk(
    content_id: "000007654321",
    apk_path: options[:apk_path],
    gms: "N"
  )
  galaxy_store_submit_app(
    content_id: "000007654321"
  )
end

Upload and submit with manual publication mode, then publish separately once the review has completed:

lane :release_manual do |options|
  galaxy_store_upload_apk(
    content_id: "000007654321",
    apk_path: options[:apk_path],
    gms: "N"
  )
  galaxy_store_set_publication_type(
    content_id: "000007654321",
    publication_type: "03"
  )
  galaxy_store_submit_app(
    content_id: "000007654321"
  )
end

# Run this lane separately once the review has passed
lane :publish do
  galaxy_store_publish_app(
    content_id: "000007654321"
  )
end

If you already manage your Play Store listing with Supply, import that content into the Galaxy Store format and push it up:

lane :import_and_upload_metadata do
  galaxy_store_import_from_supply(
    default_language_code: "ENG"
  )
  galaxy_store_upload_metadata(
    content_id: "000007654321"
  )
end

Pull current metadata from the Galaxy Store, edit the local files, then push your changes:

# Pull metadata from Galaxy Store to local files
lane :fetch_metadata do
  galaxy_store_app_info(
    content_id: "000007654321"
  )
end

# Push local metadata changes back to Galaxy Store
lane :upload_metadata do
  galaxy_store_upload_metadata(
    content_id: "000007654321"
  )
end

For any issues or feedback, please open an issue at github.com/galaxy-store-developer/fastlane-plugin-galaxystore/issues.

If you have trouble using plugins, check out the Plugins Troubleshooting guide.

fastlane is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out fastlane.tools.