Skip to main content
App Store metadata, screenshots, and localization Level: Beginner 10 min read

Fixing 'Screenshots Cannot Contain Alpha Channels' Error in App Store Connect

A complete troubleshooting guide to diagnosing and stripping alpha transparency channels from App Store screenshots using ImageMagick, native macOS utilities, and Python before uploading.

Published: 2026-11-02 • Last Updated: 2026-11-02 • Author: Kip Lawrence
Key MCP Tools: app_screenshot_upload_planapp_screenshot_upload_execute

Overview: The Invisible Transparency Trap

One of the most frequent errors encountered by developers uploading App Store marketing assets is Apple's strict validation error:

TEXT
Screenshots cannot contain alpha channels or transparency.

To the naked eye, the screenshot looks completely solid: background colors are filled, device frames are opaque, and no transparent pixels are visible. Yet App Store Connect's ingestion validator immediately rejects the upload.

Why does this happen? In digital graphics, an image saved as 32-bit RGBA contains four 8-bit color channels: Red, Green, Blue, and Alpha. Even if every single pixel in the image has an alpha value of 100% (255, meaning fully opaque), the mere presence of the 8-bit alpha data layer in the PNG file header causes Apple's automated scanner to reject the file.

Apple's App Store ingestion rules require marketing screenshots to be formatted strictly as 24-bit RGB PNG (8 bits per channel without an alpha channel) or high-quality JPEG.

TEXT
┌────────────────────────────────────────────────────────────────────────┐
│                   32-BIT RGBA vs. 24-BIT RGB ARCHITECTURE              │
│                                                                        │
│   REJECTED BY APPLE: 32-bit RGBA PNG                                   │
│   ┌───────────────┬───────────────┬───────────────┬────────────────┐   │
│   │ Red (8 bits)  │ Green (8 bits)│ Blue (8 bits) │ Alpha (8 bits) │   │
│   └───────────────┴───────────────┴───────────────┴────────────────┘   │
│   Total: 32 bits per pixel (Alpha channel present -> Upload Rejected)  │
│                                                                        │
│   ACCEPTED BY APPLE: 24-bit RGB PNG (or Baseline JPEG)                 │
│   ┌───────────────┬───────────────┬───────────────┐                    │
│   │ Red (8 bits)  │ Green (8 bits)│ Blue (8 bits) │                    │
│   └───────────────┴───────────────┴───────────────┘                    │
│   Total: 24 bits per pixel (Zero transparency -> Upload Succeeds)      │
└────────────────────────────────────────────────────────────────────────┘
Note

Transporter Codes vs. Storefront Media Errors: Developers often search for error code ITMS-9000 or ITMS-90717. Those are Transporter command-line errors returned when uploading binary .ipa packages containing transparent application icons (ITMS-90717: Invalid App Store Icon). In the App Store Connect web portal and REST API, screenshot upload rejections are reported as inline asset delivery state failures ("Screenshots cannot contain alpha channels or transparency") rather than ITMS package errors.

Important

Operational Boundary: FlightDeck is a native App Store Connect management client; it does not perform local image rasterization or pixel manipulation. When you invoke app_screenshot_upload_plan, FlightDeck inspects your local image file to ensure it conforms to Apple's specifications before staging an upload. Removing transparency from your screenshots is a local file preparation step performed on your Mac using utilities like ImageMagick, native macOS tools, or Python.


Quick Answer: How to Strip Alpha in 5 Seconds

Method 1: ImageMagick (Fastest & Lossless)

If you have ImageMagick installed (brew install imagemagick), use magick to flatten any transparent areas onto white and force 24-bit RGB PNG output:

BASH
# Flatten transparency against white and export 24-bit RGB PNG
magick screenshot.png -background white -alpha remove -alpha off png24:screenshot_clean.png

Verify that the alpha channel is gone:

BASH
sips -g hasAlpha screenshot_clean.png
# Expected output: hasAlpha: no

Method 2: Convert to High-Quality JPEG (Zero Dependencies)

Apple natively accepts JPEG files for App Store screenshots. Because the JPEG specification does not support alpha channels, converting your screenshot to a high-quality JPEG permanently eliminates all transparency:

BASH
# Convert PNG to 95% quality JPEG using native macOS sips
sips -s format jpeg -s formatOptions 95 screenshot.png --out screenshot_clean.jpg

The sips Alpha Limitation Explained

A common recommendation on developer forums is to run:

BASH
# DO NOT USE — FAILS WITH ERROR 13:
sips -s format png --deleteProperty alpha input.png --out output.png

Executing this command on macOS fails with:

TEXT
Error: Cannot do --deleteProperty alpha on file
Error 13: an unknown error occurred

Why does sips fail? Running sips --helpProperties reveals that Apple's CoreGraphics framework classifies hasAlpha as a read-only boolean property (hasAlpha boolean (read-only)). There is no mutable alpha property in sips.

If you need a 24-bit RGB PNG using only built-in macOS tools without ImageMagick, you can route the image through an intermediate uncompressed JPEG pass to force CoreGraphics to discard the alpha channel:

BASH
# Native macOS two-step alpha removal
sips -s format jpeg -s formatOptions best input.png --out /tmp/temp_noalpha.jpg
sips -s format png /tmp/temp_noalpha.jpg --out output_clean.png
rm /tmp/temp_noalpha.jpg

Copyable Prompts for Your AI Coding Assistant

1. Batch Audit Local Screenshots for Alpha Channels

Run this prompt in your AI assistant to scan your project's screenshot directory for unwanted transparency:

MARKDOWN
Please inspect all PNG images in our `screenshots/` directory:
1. Run macOS `sips -g hasAlpha -g pixelWidth -g pixelHeight` on each file.
2. Produce a summary table listing:
   - File Path
   - Dimensions (Width x Height)
   - Alpha Channel Present (yes / no)
   - Compliance Status (PASS if no alpha and matches Apple specs; FAIL if hasAlpha: yes)
3. For any files flagged with `hasAlpha: yes`, do not modify them yet—show me the report first.

2. Strip Alpha Channels and Preserve Master Copies

Once files with alpha channels are identified, use this prompt to repair them cleanly:

MARKDOWN
Please strip the alpha channels from all flagged PNG screenshots in our `screenshots/` directory:
1. First, create a backup copy of each original file in `screenshots/originals/`.
2. For each flagged image, use ImageMagick (`magick input.png -background white -alpha remove -alpha off png24:output.png`) or the native macOS JPEG conversion method to produce clean 24-bit RGB images without transparency.
3. Preserve the original pixel dimensions and sRGB color profile so that UI elements do not shift or distort.
4. Verify the repaired files using `sips -g hasAlpha` to confirm that `hasAlpha: no`.
5. Show me the before-and-after verification report.

3. Stage the Clean Screenshots with FlightDeck

After confirming that all screenshots have hasAlpha: no:

MARKDOWN
Our screenshot files are now verified with zero alpha channels. Please:
1. Inspect our active App Store Connect draft version using FlightDeck.
2. Plan an upload for `screenshots/screen_01_clean.png` targeting the English (U.S.) iPhone 6.9-inch display set.
3. Confirm that the preflight validator accepts the image dimensions and format.
4. Show me the upload details and await my confirmation before executing the upload.

Technical Tool Comparison: ImageMagick vs. sips vs. Python

Depending on your local environment, several reliable tools can eliminate alpha channels while preserving visual fidelity:

Tool Installation Command Example Best For
ImageMagick brew install imagemagick magick in.png -background white -alpha remove -alpha off png24:out.png Recommended. True 24-bit RGB output, flattens transparency against white, zero compression loss.
JPEG Conversion (sips) Pre-installed on every Mac sips -s format jpeg -s formatOptions 95 in.png --out out.jpg Fastest Native Option. JPEGs cannot have alpha channels; accepted directly by Apple.
sips Intermediate Pass Pre-installed on every Mac sips -s format jpeg in.png --out /tmp/t.jpg && sips -s format png /tmp/t.jpg --out out.png Native PNG creation without installing Homebrew packages.
Python (Pillow) pip install Pillow Image.open('in.png').convert('RGB').save('out.png') Automated build scripts in CI/CD pipelines.

Flattening Transparency vs. Disabling Alpha

It is vital to distinguish flattening transparency from merely marking pixels opaque:

  • Disabling Alpha without Flattening: If an image has transparent elements (e.g. rounded device corners or transparent status bars), simply stripping the alpha byte causes the underlying transparent pixels to render as undefined garbage or harsh black artifacts.
  • Flattening Against Background (-background white -alpha remove): Composites all semi-transparent and fully transparent pixels against a pure white background before discarding the alpha channel. This ensures clean, seamless presentation on the App Store product page.

Python (Pillow Script) Implementation

For automated cross-platform CI/CD pipelines:

PYTHON
from PIL import Image

def remove_alpha_channel(image_path, output_path):
    img = Image.open(image_path)
    if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
        # Create a white background of the same size
        background = Image.new("RGB", img.size, (255, 255, 255))
        if img.mode == "RGBA":
            background.paste(img, mask=img.split()[3]) # Use alpha channel as mask
        else:
            background.paste(img)
        background.save(output_path, "PNG", optimize=True)
        print(f"Cleaned: {output_path} (Converted to 24-bit RGB)")
    else:
        print(f"Already clean: {image_path} (Mode: {img.mode})")

remove_alpha_channel("screen_01.png", "screen_01_clean.png")

Preserving Color Fidelity & Color Profiles

A frequent pitfall when converting PNGs is color shifting—where vibrant app UI colors appear washed out or muddy after stripping the alpha channel.

To maintain pixel-perfect color accuracy on customer displays:

  1. Target sRGB IEC61966-2.1 or Display P3: Apple's App Store display pipeline expects screenshots in standard sRGB or wide-gamut Display P3 color spaces.
  2. Avoid Arbitrary Profile Stripping: Do not use aggressive image optimizers (like pngcrush with extreme settings) that strip the embedded ICC color profile.
  3. Verify Color Profile with sips: ``bash sips -g profile input.png # Expected: sRGB IEC61966-2.1 or Display P3 ``

Contrast: App Store Screenshots vs. App Icons

Developers often confuse screenshot requirements with app icon specifications:

Requirement App Store Screenshots iOS App Store Marketing Icon
Alpha Allowed? No. Alpha channels strictly forbidden. No. Alpha channels strictly forbidden.
Corner Radius Square / Unrounded. Apple applies device masks dynamically. Square. Apple applies squircle masks automatically.
Dimensions Device-specific (e.g., 1320x2868, 2064x2752). Exactly 1024 x 1024 pixels.
Max Count Up to 10 screenshots per display set. Exactly 1 icon per application.
Format PNG (24-bit RGB) or JPEG. PNG only (24-bit RGB).

Step-by-Step Resolution Workflow

MERMAID
sequenceDiagram
    autonumber
    actor Dev as Developer
    participant AI as AI Assistant (IDE)
    participant FS as Local Filesystem
    participant FD as FlightDeck MCP
    participant Apple as App Store Connect

    Dev->>AI: "Check screenshots for alpha channels"
    AI->>FS: Runs `sips -g hasAlpha screenshots/*.png`
    FS-->>AI: Reports `screen_01.png: hasAlpha: yes`
    AI->>Dev: "Alpha detected. Proposing automated repair."
    Dev->>AI: "Proceed with repair"
    AI->>FS: cp screen_01.png originals/screen_01.png
    AI->>FS: magick screen_01.png -background white -alpha remove -alpha off png24:...
    AI->>FS: sips -g hasAlpha screenshots/screen_01.png
    FS-->>AI: hasAlpha: no (Clean 24-bit RGB)
    Dev->>AI: "Upload to App Store Connect"
    AI->>FD: app_screenshot_upload_plan(filePath: "...")
    Note over FD: Inspects local file (read-only)<br/>Validates dimensions & format (PASS)
    FD-->>AI: Plan generated (Zero mutations made)
    AI-->>Dev: "Plan valid. Ready to execute upload."
    Dev->>AI: "Execute upload"
    AI->>FD: app_screenshot_upload_execute(...)
    Note over FD: Desktop Approval Center prompts developer
    Dev->>FD: Clicks [Approve]
    FD->>Apple: POST /v1/appScreenshots (Reserves asset)
    FD->>Apple: Streams bytes via HTTPS to presigned URL
    FD->>Apple: PATCH /v1/appScreenshots/{id} (uploaded: true)
    FD->>Apple: Polls assetDeliveryState until COMPLETE
    Apple-->>FD: Processing COMPLETE
    FD-->>Dev: Screenshot published successfully!

Troubleshooting Recurring Transparency Issues

1. Figma or Sketch Export Re-introducing Alpha

  • Cause: In Figma, frames default to having an invisible background fill or an explicit background color with an alpha channel enabled.
  • Fix: In Figma's right sidebar under Fill, verify that the color is set to 100% opacity. When exporting, uncheck "Show in exports" if an empty background layer exists.

2. Simulator Screenshots Containing Window Shadows

  • Cause: Taking a screenshot of the simulator window via Cmd + Shift + 4 + Space captures macOS window drop shadows with semi-transparent alpha gradients.
  • Fix: Never use macOS screenshot shortcuts on simulator windows. Always use xcrun simctl io booted screenshot output.png, which captures only the raw screen framebuffer without window shadows.

3. "Image is corrupted or unsupported format"

  • Cause: Renaming a file extension from .png to .jpg without converting the underlying binary encoding.
  • Fix: Never change image extensions manually. Always use magick, sips -s format jpeg, or sips -s format png to re-encode the image file properly.

Security & Verification Safeguards

  • Master Preservation: Automated scripts must back up original creative assets before performing image modification operations.
  • Pre-Upload Validation: FlightDeck MCP inspects local image headers and dimensions before generating staging plans, preventing failed reservation tokens on Apple's servers.
  • Human Approval Gate: All upload executions are visually previewed in the FlightDeck Desktop Approval Center before dispatch.

Official Apple Documentation

Connect Your AI Agent to App Store Connect

FlightDeck runs locally on your Mac, keeping private keys secure in your macOS Keychain and executing mutations only after your explicit approval.

Download FlightDeck on Mac App Store