# App Store Connect API-sleutel (.p8) maken en gebruiken

> Een App Store Connect API-sleutel (.p8) download je maar één keer. Rol, Issuer ID, Key ID, intrekken en gebruik met Expo, fastlane of een script.

Originele pagina: [App Store Connect API-sleutel (.p8) maken en gebruiken](https://devoria.fr/nl/blog/app-store-connect-api-sleutel-p8-maken-gebruiken)
Auteur: [Mehdi Azizi](https://devoria.fr/nl/mehdi-azizi)
Publicatie: 2026-11-04
Laatste inhoudsrevisie: 2026-11-04


Met een App Store Connect API-sleutel kan een tool, zoals EAS, fastlane, RevenueCat of je eigen script, acties uitvoeren op je account zonder je wachtwoord en zonder tweestapsverificatie. **Apple bewaart de publieke helft van de sleutel, en jij downloadt de privéhelft, een `.p8`-bestand, maar één keer.** Met dat bestand, de Issuer ID en de Key ID onderteken je tokens die voor de meeste verzoeken maximaal 20 minuten geldig zijn.

Ik publiceer mijn iOS-apps, waaronder TradaZen en Nolera, met Expo. Eén teamsleutel met de rol App Manager gebruik ik voor RevenueCat, voor mijn Expo-builds en voor een command-line tool waarmee ik mijn store-pagina's bewerk. Deze gids volgt de pagina's van Apple, Expo en fastlane, nagelezen op 3 november 2026. Verwar hem niet met de sleutels van diensten die je in de code van een app stopt: die komen aan bod in [geheime API-sleutel in een Expo-app](https://devoria.fr/nl/blog/geheime-api-sleutel-expo-app-beschermen).

## Wat een App Store Connect API-sleutel doet

Volgens [de documentatie van Apple](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api) vereist de App Store Connect API een JWT-token bij elk verzoek. Dat token maak en onderteken je met je privésleutel. De sleutel werkt alleen voor deze API: je kunt hem niet gebruiken voor andere diensten van Apple.

Het voordeel past in één zin: **niemand hoeft de verbinding goed te keuren.** Je Apple ID loopt vast op tweestapsverificatie, en dat blokkeert elke automatisering. De gids [EAS Submit iOS](https://devoria.fr/nl/blog/eas-submit-ios-expo-app-publiceren-app-store) laat zien wat dat verandert bij het insturen van een Expo-app.

## Eerst: toegang tot de API aanvragen

Je eerste sleutel kun je niet meteen maken. [De hulp van App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api) is duidelijk: **de Account Holder moet eerst toegang tot de API aanvragen.** Die opent Users and Access, klikt op Integrations en daarna op Request Access. Apple beoordeelt elke aanvraag afzonderlijk.

De Account Holder is de persoon die het account heeft aangemaakt. Als je net begint, ben jij dat: de gids [Apple-ontwikkelaarsaccount](https://devoria.fr/nl/blog/apple-developer-account-kosten-gratis-of-betaald) legt de inschrijving uit.

## Teamsleutel of individuele sleutel

Apple biedt twee soorten sleutels. Dit zijn de verschillen, gehaald uit [de documentatie](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api) en [de hulp van App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api):

| Criterium                      | Teamsleutel                   | Individuele sleutel     |
| ------------------------------ | ----------------------------- | ----------------------- |
| Wie hem kan maken              | Account Holder of Admin       | Bijna elke gebruiker    |
| Toegankelijke apps             | Allemaal, zonder uitzondering | Die van de gebruiker    |
| Rechten                        | De gekozen rol                | Die van de gebruiker    |
| Aantal sleutels                | Meerdere                      | Eén actieve per persoon |
| Certificaten en profielen      | Ja, afhankelijk van de rol    | Nee                     |
| Verkoop, financiën, notaryTool | Afhankelijk van de rol        | Nee                     |
| Veld in het token              | `iss` = Issuer ID             | `sub` = `user`          |

"Bijna elke gebruiker" betekent volgens Apple: Account Holder, Admin, App Manager, Customer Support, Developer en Marketing, tenzij een Admin of de Account Holder hun het recht heeft afgenomen om een individuele sleutel te maken.

**Kies voor Expo of fastlane een teamsleutel.** Een individuele sleutel heeft geen toegang tot de provisioning-endpoints, die certificaten en profielen aanmaken. [De documentatie van fastlane](https://docs.fastlane.tools/app-store-connect-api/) bevestigt het: teamsleutels zijn vereist voor alles wat met provisioning te maken heeft.

## Welke rol je je sleutel geeft

Een teamsleutel heeft toegang tot alle apps van het account, ongeacht de rol. De rol bepaalt wat hij mag doen. **Apple waarschuwt dat een Admin-sleutel gebruikers kan aanmaken en verwijderen**: geef de kleinste rol die je gebruik dekt. De rechten hieronder komen uit de [rollentabel van Apple](https://developer.apple.com/help/account/access/roles/).

| Gebruik van de sleutel                       | Rollen die het toestaan       |
| -------------------------------------------- | ----------------------------- |
| Builds insturen                              | Admin, App Manager, Developer |
| TestFlight-builds beheren                    | Admin, App Manager            |
| Certificaten en profielen maken              | Admin, App Manager            |
| Een app ter review insturen                  | Admin, App Manager            |
| Producten en prijzen importeren (RevenueCat) | Minimaal App Manager          |
| Andere teamsleutels maken                    | Admin                         |

De RevenueCat-regel komt uit [hun documentatie](https://www.revenuecat.com/docs/service-credentials/itunesconnect-app-specific-shared-secret/app-store-connect-api-key-configuration). De gids van Expo [geeft de sleutel de rol Admin](https://github.com/expo/fyi/blob/main/creating-asc-api-key.md). Voor mijn apps is App Manager genoeg: EAS maakt er de distributieprofielen mee, en RevenueCat importeert de producten.

Zodra de sleutel is gemaakt, [kun je naam en rol niet meer wijzigen](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api). Wil je iets veranderen, dan moet je hem intrekken en een nieuwe maken.

## Een teamsleutel maken, stap voor stap

Je hebt een Admin- of Account Holder-account nodig. Volgens [Apple](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api):

1. **Open Users and Access**, en dan het tabblad Integrations.
2. **Kies App Store Connect API** in de linkerkolom, en dan het tabblad Team Keys.
3. **Klik op Generate API Key**, of op de knop +.
4. **Geef de sleutel een naam.** Die is alleen voor jou, hij hoort niet bij de sleutel zelf. Noem hem naar de tool die hem gaat gebruiken.
5. **Kies de rol** onder Access en klik op Generate.
6. **Download de privésleutel** via de link Download API Key.

> De downloadlink verdwijnt zodra je het bestand hebt gedownload, en Apple bewaart geen kopie. Berg de `.p8` op voordat je de pagina sluit.

Noteer daarna de twee identificatiecodes. Volgens [de pagina van Apple over tokens](https://developer.apple.com/documentation/appstoreconnectapi/generating-tokens-for-api-requests) **staat de Issuer ID bovenaan de pagina Integrations**, met een knop Copy. De Key ID staat in de lijst met actieve sleutels: beweeg er met je muis over om Copy Key ID te zien. De Issuer ID is voor alle teamsleutels van het account dezelfde. De Key ID is per sleutel uniek.

Voor een individuele sleutel gaat het sneller: open je gebruikersprofiel, scrol naar Individual API Key en klik op Generate API Key. Ook hier kun je maar één keer downloaden.

## Het .p8-bestand opbergen

Apple vraagt je de sleutel als een wachtwoord te behandelen: **deel hem niet, zet hem niet in een coderepository en stop hem nooit in de code van een app.** Mijn routine:

- **Een map buiten het project**, of de secrets-manager van je CI-tool.
- **De sleutelmap in je `.gitignore`**, als het bestand even in het project moet staan voor een upload.
- **Strikte rechten.** Een command-line tool voor App Store Connect weigerde mijn `.p8` zolang het bestand leesbaar was voor andere accounts. Een `chmod 600` loste het op.
- **Eén sleutel per tool.** Apple laat je [meerdere sleutels maken](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api), met de rollen die jij kiest.

Dat laatste punt heb ik in het begin niet toegepast. Mijn App Manager-sleutel dient tegelijk voor RevenueCat, mijn builds en mijn tool voor store-pagina's. Als ik hem moet intrekken, vallen drie tools tegelijk om. **Als ik het opnieuw moest doen, zou ik één sleutel per tool maken**, zodat ik er één kan uitschakelen zonder de andere te raken.

## Gebruiken met Expo

Drie manieren om de sleutel aan EAS te geven:

- **EAS hem laten beheren.** `eas credentials --platform ios` kan een sleutel maken en die op de servers van Expo bewaren. Dat is de eenvoudigste weg.
- **Hem opgeven in `eas.json`.** Het `submit`-profiel accepteert `ascApiKeyPath`, `ascApiKeyIssuerId` en `ascApiKeyId`. Volgens [de referentie van eas.json](https://docs.expo.dev/eas/json/) accepteren die velden omgevingsvariabelen, zoals `$ASC_API_KEY_PATH`.
- **Hem via de omgeving doorgeven.** [De repository van EAS CLI](https://github.com/expo/eas-cli/blob/main/packages/eas-cli/README.md) documenteert `EXPO_ASC_API_KEY_PATH`, `EXPO_ASC_KEY_ID` en `EXPO_ASC_ISSUER_ID`. Bij een individuele sleutel laat je de Issuer ID weg.

Een beperking bij builds die je moet kennen: [Expo meldt](https://docs.expo.dev/build-reference/ios-capabilities/) dat de officiële API geen App Group, Merchant ID of CloudKit-container kan koppelen. Daarvoor moet je lokaal inloggen met je Apple ID. Ik maakte het mee bij Nolera met de app group van de widget: de sleutel zette de capability aan, maar koppelde de groep niet. Die koppeling heb ik in het ontwikkelaarsportaal van Apple gedaan. **Als het synchroniseren van capabilities vastloopt, schakelt `EXPO_NO_CAPABILITY_SYNC=1` het uit**, en zet je de capability zelf aan op de app-ID. Het ondertekenen van builds staat uitgelegd in [iOS-certificaat en provisioning profile](https://devoria.fr/nl/blog/ios-certificaat-provisioning-profile-expo).

## Gebruiken met fastlane

[fastlane](https://docs.fastlane.tools/app-store-connect-api/) leest de sleutel uit een JSON-bestand. De velden `key_id`, `issuer_id` en `key`, de inhoud van de `.p8`, zijn verplicht. `duration` en `in_house` zijn optioneel. Nepwaarden:

```json
{
  "key_id": "XXXXXXXXXX",
  "issuer_id": "your-issuer-id",
  "key": "-----BEGIN PRIVATE KEY-----\nMIGT...\n-----END PRIVATE KEY-----",
  "duration": 1200,
  "in_house": false
}
```

Dat bestand geef je daarna aan een action, bijvoorbeeld `fastlane pilot distribute --api_key_path fastlane/cle.json`. In een Fastfile neemt de action `app_store_connect_api_key` de parameters `key_id`, `issuer_id` en `key_filepath`. Een sessie duurt maximaal 1.200 seconden, dus 20 minuten. Niet alle actions ondersteunen het: fastlane meldt bijvoorbeeld dat `produce` en `pem` niet werken met een API-sleutel.

## Gebruiken in je eigen script

Zonder tool maak je het token zelf. [Apple legt het recept vast](https://developer.apple.com/documentation/appstoreconnectapi/generating-tokens-for-api-requests):

- **Header**: `alg` is `ES256`, `kid` is je Key ID, `typ` is `JWT`.
- **Payload, teamsleutel**: `iss`, je Issuer ID; `iat`, het aanmaaktijdstip; `exp`, het verlooptijdstip; `aud`, met de waarde `appstoreconnect-v1`.
- **Payload, individuele sleutel**: `sub` is `user` in plaats van `iss`.
- **Duur**: boven de 20 minuten weigert Apple het token voor de meeste verzoeken.

In Python, met de bibliotheek PyJWT en de cryptografische afhankelijkheid, geïnstalleerd met `pip install pyjwt[crypto]` volgens [de documentatie](https://pyjwt.readthedocs.io/en/stable/installation.html). Zet in de Terminal van je Mac aanhalingstekens: `pip install "pyjwt[crypto]"`, anders weigert zsh de vierkante haken.

```python
import time
import jwt

KEY_ID = "XXXXXXXXXX"
ISSUER_ID = "your-issuer-id"

with open("AuthKey_XXXXXXXXXX.p8") as f:
    private_key = f.read()

now = int(time.time())
token = jwt.encode(
    {"iss": ISSUER_ID, "iat": now, "exp": now + 20 * 60, "aud": "appstoreconnect-v1"},
    private_key,
    algorithm="ES256",
    headers={"kid": KEY_ID, "typ": "JWT"},
)
print(token)
```

Daarna stuur je het mee in de `Authorization`-header, zoals in het voorbeeld van Apple:

```bash
curl -H "Authorization: Bearer $TOKEN" "https://api.appstoreconnect.apple.com/v1/apps"
```

Ik heb dit script op 3 november 2026 uitgevoerd met een wegwerpsleutel die ik op mijn eigen computer had gemaakt: de header en payload van het token komen overeen met de pagina van Apple, en de ES256-handtekening klopt. Ik heb het niet naar de API van Apple gestuurd met deze testsleutel, want die bestaat niet bij Apple. **Hergebruik hetzelfde token zolang het geldig is**: Apple raadt dat aan voor betere prestaties.

## Een sleutel intrekken

Trek een sleutel in zodra hij kwijt is, gecompromitteerd is, of een tool hem niet meer gebruikt. Volgens [de hulp van App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api), met een Account Holder- of Admin-account:

1. Open Users and Access, en dan Integrations.
2. Kies Team Keys, of Individual Keys, en klik op Edit.
3. Vink de sleutels aan die je wilt intrekken en kies Revoke Key.
4. Bevestig met Revoke.

**Een ingetrokken sleutel kun je nooit meer activeren.** [Apple toont hem](https://developer.apple.com/documentation/appstoreconnectapi/revoking-api-keys) 30 dagen onder Revoked. Elke tool die hem gebruikte, faalt dan bij de authenticatie. Bij Expo is de melding "[App Store Connect rejected the API authentication credentials](https://github.com/expo/eas-cli/blob/main/packages/build-tools/src/steps/utils/ios/AscApiClient.ts)". Die melding en andere uploadfouten worden uitgelegd in [uploadfouten met EAS en hoe je ze oplost](https://devoria.fr/nl/blog/eas-submit-ios-fouten-oplossen). Is de sleutel niet gecompromitteerd, zet de nieuwe dan klaar voordat je de oude uitschakelt. Is hij dat wel, dan vraagt Apple je hem meteen in te trekken.

Voor je eigen individuele sleutel: je profiel, Individual API Key, en dan Revoke.

## Mijn checklist voor de .p8-sleutel

- De Account Holder heeft toegang tot de API aangevraagd.
- De sleutel is een teamsleutel als hij voor builds of profielen dient.
- De rol is de kleinste die het gebruik dekt, en de naam zegt welke tool hem gebruikt.
- De `.p8` staat buiten de repository, met strikte rechten en een versleutelde back-up.
- De Issuer ID en de Key ID staan ernaast genoteerd, zonder het bestand.
- Elke tool heeft zijn eigen sleutel, zodat je er één kunt intrekken.

## Je publicatie automatiseren zonder je sleutel bloot te geven

De sleutel is maar één onderdeel van het traject. De [iOS & Android Kit](https://devoria.fr/nl/kits/ios) vertrekt vanuit de startcode van mijn apps, abonnementen inbegrepen, en volgt vier stappen tot in de App Store, in je eigen tempo. Als je RevenueCat met deze sleutel koppelt, vind je de volledige opzet in [RevenueCat en het in-app-abonnement op iOS](https://devoria.fr/nl/blog/revenuecat-abonnement-instellen-ios-app).

Bereid je je eerste release voor? [Doe je gratis diagnose](https://devoria.fr/nl/diagnostic): die vertelt je wat je echt tegenhoudt en stuurt je mijn checklist tegen afwijzingen door Apple. De pagina [een app publiceren in de App Store](https://devoria.fr/nl/expertise/app-publiceren-in-app-store) behandelt elke stap, van de store-pagina tot de goedkeuring.

## Veelgestelde vragen

### Hoe maak je een App Store Connect API-sleutel?

De Account Holder vraagt eerst toegang tot de API aan. Daarna opent een Admin Users and Access, tabblad Integrations, App Store Connect API, Team Keys. Die klikt op Generate API Key, kiest een naam en een rol, maakt de sleutel aan en downloadt het `.p8`-bestand.

### Kun je een verloren .p8-sleutel opnieuw downloaden?

Nee. Het bestand download je maar één keer, en Apple bewaart geen kopie. Trek de verloren sleutel in, maak een nieuwe en werk elke tool bij die hem gebruikte.

### Waar vind je de Issuer ID en de Key ID?

In App Store Connect, menu Users and Access, tabblad Integrations. De Issuer ID staat bovenaan de pagina. De Key ID staat in de lijst met actieve sleutels. Een individuele sleutel gebruikt geen Issuer ID.

### Welke rol geef je een sleutel die Expo gebruikt?

De gids van Expo geeft de rol Admin. Volgens de rollentabel van Apple is App Manager genoeg om builds in te sturen en certificaten en profielen te maken. Dat is de rol van mijn sleutel, die ik voor mijn Expo-builds gebruik.

### Kun je de rol van een API-sleutel wijzigen?

Nee. Apple laat je naam en rol van een sleutel na het aanmaken niet meer wijzigen. Trek hem in en maak een nieuwe met de juiste rol.

### Verloopt een App Store Connect API-sleutel?

De pagina's van Apple noemen geen vervaldatum voor de sleutel, alleen intrekking. Het zijn de tokens die je ermee ondertekent die verlopen, na maximaal 20 minuten voor de meeste verzoeken.


## Je project

[Review Kit](https://devoria.fr/nl/kits/app-review): Mijn App Store-reviewchecklist, mijn opgeloste afwijzingen door Apple, die voor Google Play en drie Claude Code-skills. € 49.

[iOS & Android Kit](https://devoria.fr/nl/kits/ios): Bouw je iPhone- en Android-app met Claude Code: de startcode van mijn apps, de route naar de stores en alle kits. € 99.

[Diagnose: wat staat er tussen jou en je iPhone-app](https://devoria.fr/nl/diagnostic): 7 vragen, 60 seconden: je weet wat je echt tegenhoudt om je iPhone-app te publiceren, je traject in 4 stappen en de kit die bij je past.