Solucionando Rechazos de Iconos de App Store: sRGB, Canales Alfa y Otras Trampas

App Store Connect icon validation fails silently. You upload a 1024×1024 PNG that looks perfect in every image editor you own, and the response is some variation of “The image could not be processed.” No color space mentioned. No reference to alpha. Just a wall between your submission and the App Store.

In reality, the validator checks a narrow set of technical properties, and any one of them failing produces the same generic error. The three most common causes are a non-sRGB color profile (usually Display P3 from modern design tools), an alpha channel the store explicitly prohibits, and – less frequently – an indexed color mode that shouldn’t appear in an icon produced in 2025 but still does when files pass through older optimization pipelines. All three are fixable from the terminal in under a minute once you know what you’re looking at.

What App Store Connect Actually Requires

Apple’s requirements for the App Store listing icon are specific. The file must be a PNG. The dimensions must be 1024×1024 pixels. There must be no alpha channel – not a partially transparent alpha, not a fully opaque one embedded in the metadata, simply no alpha data at all. The color space must be sRGB. And the color mode must be RGB TrueColor, not an indexed palette.

The constraint on alpha exists because App Store Connect applies its own corner radius and compositing to icons. An icon with an alpha channel would interfere with that process. The sRGB constraint exists because the store renders icons across a wide range of devices with different display profiles; sRGB is the common baseline. Display P3, Apple’s wide-gamut color space that ships enabled by default in Figma, Sketch, and Affinity Designer on M-series Macs, is not accepted despite being Apple’s own format.

Diagnosing the Problem with sips

macOS ships with sips (Scriptable Image Processing System), a command-line tool that can inspect and transform images without any third-party dependencies. It is the fastest way to see exactly what your icon file contains.

sips --getProperty all icon.png

The output is a flat list of properties. The fields that matter for App Store validation are hasAlpha, space, and profile. A file with problems typically shows something like this:

hasAlpha: yes
space: RGB
profile: Display P3

That combination will fail. The space: RGB value does not distinguish between generic RGB and sRGB – the profile field is what disambiguates. A clean icon ready for upload should show hasAlpha: no and a profile reading “sRGB IEC61966-2.1” or equivalent.

You can also query individual properties if you want a faster check during a build script:

sips --getProperty hasAlpha icon.png
sips --getProperty profile icon.png

The Color Profile Problem

The most common rejection cause is a Display P3 color profile. Modern Mac displays are P3-capable, and design tools on Apple Silicon default to exporting in the active display’s color space unless you explicitly override that. Figma’s Document Settings default to “Unmanaged” until you set it to sRGB. Sketch has a similar per-document toggle. If your designer is working on a MacBook Pro and exports without checking this setting, the resulting PNG is P3.

The fix is to convert – not just tag – the file to sRGB. There is an important distinction here. The sips -s profile flag embeds a different profile in the metadata without transforming the pixel values. That produces a lie: the pixels are encoded as P3 but labeled as sRGB. The correct flag is --matchTo, which performs an actual color space conversion:

sips --matchTo '/System/Library/ColorSync/Profiles/sRGB Profile.icc'   icon.png --out icon-srgb.png

This reads the source pixels as P3, converts them to sRGB equivalents, and writes a new file. The color shift is imperceptible on most displays but matters for validator compliance. After running this, confirm the result:

sips --getProperty profile icon-srgb.png

The profile should now report “sRGB IEC61966-2.1”.

Removing the Alpha Channel

sips cannot remove alpha channels. It can inspect them, and it can add a profile to a file that has one, but stripping the alpha layer requires a different tool. ImageMagick’s convert handles this cleanly:

convert icon-srgb.png -background white -alpha remove -alpha off icon-final.png

The flags work in sequence. -background white sets the matte color that will replace transparent pixels. -alpha remove composites the image against that background, eliminating transparency. -alpha off removes the alpha channel from the output metadata entirely. The result is a flat, opaque PNG that the App Store validator accepts.

If your icon has no actual transparency – all pixels are fully opaque – but the file still carries an alpha channel in its structure, you can use pngcrush instead. It removes the alpha chunk from the PNG metadata without any pixel transformation:

pngcrush -ow -rem alla icon.png

The -rem alla flag removes all ancillary alpha chunks in place. This is faster and lossless, but it only works when there is no actual transparency to flatten. If identify -verbose icon.png | grep Alpha shows any non-opaque pixels, use the ImageMagick route.

The Indexed Color Mode Edge Case

RGB TrueColor stores each pixel as three independent 8-bit (or 16-bit) channel values. Indexed mode stores a palette of colors and references them by integer index – a format designed for small GIFs in 1989, not app icons. Most design tools never produce indexed PNGs, but some web optimization pipelines – especially older ones using tools like pngquant aggressively – can convert TrueColor icons to indexed as a side effect of palette quantization.

To check the color mode with ImageMagick:

identify -verbose icon.png | grep -E "^  Type"

A TrueColor file reports Type: TrueColor or Type: TrueColorAlpha. An indexed file reports Type: Palette. If you see Palette, convert it:

convert icon.png -type TrueColor icon-truecolor.png

In practice, this is the least common rejection reason, but it appears reliably in codebases where icons have been processed through an asset optimization script at some point in their history.

The Combined Fix Pipeline

When an icon has all three problems – P3 profile, alpha channel, and possibly stale metadata – the cleanest approach is a single ImageMagick command that handles everything:

sips --matchTo '/System/Library/ColorSync/Profiles/sRGB Profile.icc'   icon.png --out /tmp/icon-srgb.png   && convert /tmp/icon-srgb.png     -type TrueColor     -background white     -alpha remove     -alpha off     -strip     icon-final.png

The -strip flag at the end removes all embedded profiles, comments, and ancillary metadata chunks from the output. This produces the smallest, cleanest PNG possible – exactly what App Store Connect expects. After running this, a final sips --getProperty all icon-final.png should confirm hasAlpha: no, space: RGB, and either no profile or the sRGB profile explicitly embedded.

Fixing the Problem at the Source

Command-line fixes work, but the real solution is configuring your design tool to export correctly the first time. In Figma, go to File → Document Settings and set the color profile to sRGB before exporting any assets. In Sketch, the equivalent is in Document → Color Profile. In Affinity Designer, check the Document Setup → Color Format settings and ensure the profile is set to sRGB IEC61966-2.1.

For App Store icons specifically, the export should be PNG, 1024×1024, no scaling applied, with the sRGB profile active. If your CI/CD pipeline uploads to App Store Connect via xcrun altool or the App Store Connect API directly, add a validation step before upload that runs sips --getProperty hasAlpha and fails the build if alpha is present. Catching this before the API call saves the round-trip time and the manual investigation.

The underlying lesson here is that App Store Connect’s validation is doing exactly what Apple documented. The problem is that the documentation is not surfaced during the upload workflow, and the error messages are not matched to specific failing conditions. Once you know the three properties being checked, the validation process stops being mysterious and becomes a straightforward checklist.

Related Insights

• From SwiftUI Concept to App Store in Weeks – The broader timeline and decisions involved in getting an app through submission, including the provisioning and review process.
• Building an Exam Prep App with Thousands of Questions – Architecture decisions for a modular iOS app with a Supabase backend and offline capability.
• Swift 6 Concurrency: A Practical Migration Guide – Migrating SwiftUI apps to Swift 6 strict concurrency, with real compiler warnings and their fixes.