# Chave API App Store Connect (.p8): como criar e usar

> A chave API App Store Connect (.p8) só pode ser baixada uma vez. Função, Issuer ID, Key ID, revogação e uso com Expo, fastlane ou um script.

Página original: [Chave API App Store Connect (.p8): como criar e usar](https://devoria.fr/pt-br/blog/chave-api-app-store-connect-p8)
Autor: [Mehdi Azizi](https://devoria.fr/pt-br/mehdi-azizi)
Publicação: 2026-11-04
Última revisão do conteúdo: 2026-11-04


Uma chave API App Store Connect permite que uma ferramenta, como EAS, fastlane, RevenueCat ou o seu próprio script, aja na sua conta sem a sua senha e sem a autenticação de dois fatores. **A Apple guarda a metade pública da chave, e você baixa a metade privada, um arquivo `.p8`, uma única vez.** Com esse arquivo, o Issuer ID e o Key ID, você assina tokens válidos por no máximo 20 minutos para a maioria das requisições.

Eu publico meus apps iOS, entre eles TradaZen e Nolera, com Expo. Uma chave de equipe com a função App Manager serve para o RevenueCat, para os meus builds Expo e para uma ferramenta de linha de comando que edita minhas páginas na loja. Este guia segue as páginas da Apple, da Expo e do fastlane relidas em 3 de novembro de 2026. Não confunda com as chaves de serviços colocadas no código de um app: essas são tratadas em [chave API secreta em um app Expo](https://devoria.fr/pt-br/blog/chave-api-secreta-expo-o-que-proteger).

## O que faz uma chave API App Store Connect

Segundo [a documentação da Apple](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api), a API App Store Connect exige um token JWT em cada requisição. Você gera esse token e assina com a sua chave privada. A chave serve só para essa API: você não pode usá-la em outros serviços da Apple.

A vantagem cabe numa frase: **ninguém precisa validar o login.** O seu Apple ID esbarra na autenticação de dois fatores, o que trava qualquer automação. O guia [EAS Submit iOS](https://devoria.fr/pt-br/blog/eas-submit-ios-publicar-app-expo-app-store) mostra o que isso muda no envio de um app Expo.

## Antes de tudo: pedir acesso à API

A primeira chave não pode ser criada de cara. [A ajuda do App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api) é clara: **o Account Holder precisa primeiro pedir acesso à API.** Ele abre Users and Access, clica em Integrations e depois em Request Access. A Apple analisa o pedido caso a caso.

O Account Holder é a pessoa que cadastrou a conta. Se você está começando, é você: o guia [conta de desenvolvedor Apple](https://devoria.fr/pt-br/blog/conta-desenvolvedor-apple-preco) detalha o cadastro.

## Chave de equipe ou chave individual

A Apple oferece dois tipos de chave. Veja as diferenças, tiradas da [documentação](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api) e da [ajuda do App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api):

| Critério                     | Chave de equipe         | Chave individual       |
| ---------------------------- | ----------------------- | ---------------------- |
| Quem pode gerar              | Account Holder ou Admin | Quase qualquer usuário |
| Apps acessíveis              | Todos, sem exceção      | Os do usuário          |
| Permissões                   | A função escolhida      | As do usuário          |
| Número de chaves             | Várias                  | Uma ativa por pessoa   |
| Certificados e perfis        | Sim, conforme a função  | Não                    |
| Vendas, finanças, notaryTool | Conforme a função       | Não                    |
| Campo do token               | `iss` = Issuer ID       | `sub` = `user`         |

"Quase qualquer usuário" quer dizer, segundo a Apple: Account Holder, Admin, App Manager, Customer Support, Developer e Marketing, a menos que um Admin ou o Account Holder tenha tirado deles o direito de gerar uma chave individual.

**Para Expo ou fastlane, escolha uma chave de equipe.** Uma chave individual não tem acesso aos endpoints de provisionamento, os que criam certificados e perfis. [A documentação do fastlane](https://docs.fastlane.tools/app-store-connect-api/) confirma: chaves de equipe são obrigatórias para qualquer acesso ligado ao provisionamento.

## Qual função dar à sua chave

Uma chave de equipe acessa todos os apps da conta, seja qual for a função. A função decide o que ela pode fazer. **A Apple avisa que uma chave Admin pode criar e excluir usuários**: dê a menor função que cubra o seu uso. As permissões abaixo vêm da [tabela de funções da Apple](https://developer.apple.com/help/account/access/roles/).

| Uso da chave                            | Funções que permitem          |
| --------------------------------------- | ----------------------------- |
| Enviar builds                           | Admin, App Manager, Developer |
| Gerenciar builds do TestFlight          | Admin, App Manager            |
| Criar certificados e perfis             | Admin, App Manager            |
| Enviar um app para revisão              | Admin, App Manager            |
| Importar produtos e preços (RevenueCat) | App Manager no mínimo         |
| Gerar outras chaves de equipe           | Admin                         |

A linha do RevenueCat vem da [documentação dele](https://www.revenuecat.com/docs/service-credentials/itunesconnect-app-specific-shared-secret/app-store-connect-api-key-configuration). Já o guia da Expo [dá a função Admin](https://github.com/expo/fyi/blob/main/creating-asc-api-key.md) à chave. Nos meus apps, a função App Manager basta: o EAS cria os perfis de distribuição com ela, e o RevenueCat importa os produtos.

Depois que a chave é gerada, [você não pode mais alterar nem o nome nem a função](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api). Para mudar, é preciso revogá-la e gerar outra.

## Criar uma chave de equipe, passo a passo

Você precisa de uma conta Admin ou Account Holder. Segundo [a Apple](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api):

1. **Abra Users and Access**, depois a aba Integrations.
2. **Escolha App Store Connect API** na coluna da esquerda, depois a aba Team Keys.
3. **Clique em Generate API Key**, ou no botão +.
4. **Dê um nome à chave.** Ele serve só para você, não faz parte da chave. Use o nome da ferramenta que vai usá-la.
5. **Escolha a função** em Access e clique em Generate.
6. **Baixe a chave privada** pelo link Download API Key.

> O link de download some assim que você baixa o arquivo, e a Apple não guarda nenhuma cópia. Guarde o `.p8` antes de fechar a página.

Depois anote os dois identificadores. Segundo [a página da Apple sobre tokens](https://developer.apple.com/documentation/appstoreconnectapi/generating-tokens-for-api-requests), **o Issuer ID aparece no topo da página Integrations**, com um botão Copy. O Key ID aparece na lista de chaves ativas: passe o mouse sobre ele para ver Copy Key ID. O Issuer ID é o mesmo para todas as chaves de equipe da conta. O Key ID é próprio de cada chave.

Para uma chave individual, é mais rápido: abra o seu perfil de usuário, desça até Individual API Key e clique em Generate API Key. O download também é único.

## Guardar o arquivo .p8

A Apple pede para tratar a chave como uma senha: **não compartilhe, não coloque num repositório de código, nunca inclua no código de um app.** Minha rotina:

- **Uma pasta fora do projeto**, ou o gerenciador de segredos da sua ferramenta de integração contínua.
- **A pasta das chaves no seu `.gitignore`**, se o arquivo precisar ficar no projeto durante um envio.
- **Permissões restritas.** Uma ferramenta de linha de comando para o App Store Connect recusou meu `.p8` enquanto o arquivo podia ser lido por outras contas. Um `chmod 600` resolveu.
- **Uma chave por ferramenta.** A Apple permite [gerar várias chaves](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api), com as funções que você quiser.

Esse último ponto eu não segui no começo. Minha chave App Manager serve ao mesmo tempo para o RevenueCat, meus builds e minha ferramenta de páginas. Se eu precisar revogá-la, três ferramentas caem juntas. **Se fosse para refazer, eu criaria uma chave por ferramenta**, para poder cortar uma sem mexer nas outras.

## Usar com Expo

Três jeitos de passar a chave para o EAS:

- **Deixar o EAS gerenciar.** `eas credentials --platform ios` pode criar uma chave e guardá-la nos servidores da Expo. É o caminho mais simples.
- **Declarar no `eas.json`.** O perfil `submit` aceita `ascApiKeyPath`, `ascApiKeyIssuerId` e `ascApiKeyId`. Segundo [a referência do eas.json](https://docs.expo.dev/eas/json/), esses campos aceitam variáveis de ambiente, como `$ASC_API_KEY_PATH`.
- **Passar pelo ambiente.** [O repositório do EAS CLI](https://github.com/expo/eas-cli/blob/main/packages/eas-cli/README.md) documenta `EXPO_ASC_API_KEY_PATH`, `EXPO_ASC_KEY_ID` e `EXPO_ASC_ISSUER_ID`. Para uma chave individual, omita o Issuer ID.

Um limite que você precisa conhecer nos builds: [a Expo explica](https://docs.expo.dev/build-reference/ios-capabilities/) que a API oficial não consegue vincular um App Group, um Merchant ID ou um contêiner CloudKit. Nesse caso, é preciso fazer login com o seu Apple ID, localmente. Passei por isso no Nolera com o grupo de apps do widget: a chave ativava a capability, sem vincular o grupo. Fiz esse vínculo no portal de desenvolvedor da Apple. **Se a sincronização das capabilities travar, `EXPO_NO_CAPABILITY_SYNC=1` a desativa**, e você ativa a capability manualmente no identificador do app. A assinatura dos builds está detalhada em certificado e provisioning profile iOS.

## Usar com fastlane

O [fastlane](https://docs.fastlane.tools/app-store-connect-api/) lê a chave de um arquivo JSON. Os campos `key_id`, `issuer_id` e `key`, o conteúdo do `.p8`, são obrigatórios. `duration` e `in_house` são opcionais. Valores fictícios:

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

Depois você passa esse arquivo para uma action, por exemplo `fastlane pilot distribute --api_key_path fastlane/cle.json`. Num Fastfile, a action `app_store_connect_api_key` recebe `key_id`, `issuer_id` e `key_filepath`. A duração da sessão não passa de 1.200 segundos, ou seja, 20 minutos. Nem todas as actions têm suporte: o fastlane avisa, por exemplo, que `produce` e `pem` não funcionam com uma chave API.

## Usar no seu próprio script

Sem ferramenta, você mesmo monta o token. [A Apple define a receita](https://developer.apple.com/documentation/appstoreconnectapi/generating-tokens-for-api-requests):

- **Cabeçalho**: `alg` vale `ES256`, `kid` vale o seu Key ID, `typ` vale `JWT`.
- **Payload, chave de equipe**: `iss`, o seu Issuer ID; `iat`, o horário de criação; `exp`, o horário de expiração; `aud`, que vale `appstoreconnect-v1`.
- **Payload, chave individual**: `sub` vale `user` no lugar de `iss`.
- **Duração**: acima de 20 minutos, a Apple rejeita o token na maioria das requisições.

Em Python, com a biblioteca PyJWT e sua dependência de criptografia, instalada com `pip install pyjwt[crypto]` segundo [a documentação dela](https://pyjwt.readthedocs.io/en/stable/installation.html). No terminal do Mac, use aspas: `pip install "pyjwt[crypto]"`, senão o zsh recusa os colchetes.

```python
import time
import jwt

KEY_ID = "XXXXXXXXXX"
ISSUER_ID = "seu-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)
```

Depois você envia o token no cabeçalho `Authorization`, como no exemplo da Apple:

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

Rodei esse script em 3 de novembro de 2026 com uma chave descartável gerada na minha máquina: o cabeçalho e o payload do token batem com a página da Apple, e a assinatura ES256 é verificada. Não enviei o token para a API da Apple com essa chave de teste, que não existe na Apple. **Reutilize o mesmo token enquanto ele for válido**: a Apple recomenda isso para ter melhor desempenho.

## Revogar uma chave

Revogue uma chave assim que ela for perdida, comprometida, ou quando uma ferramenta não a usar mais. Segundo [a ajuda do App Store Connect](https://developer.apple.com/help/app-store-connect/get-started/app-store-connect-api), com uma conta Account Holder ou Admin:

1. Abra Users and Access, depois Integrations.
2. Escolha Team Keys, ou Individual Keys, e clique em Edit.
3. Marque as chaves a revogar e clique em Revoke Key.
4. Confirme com Revoke.

**Uma chave revogada nunca é reativada.** [A Apple a exibe](https://developer.apple.com/documentation/appstoreconnectapi/revoking-api-keys) por 30 dias em Revoked. Toda ferramenta que a usava passa a falhar na autenticação. Com Expo, a mensagem é "[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)". Essa mensagem e as outras falhas de envio são explicadas em [os erros de envio com EAS e como corrigir](https://devoria.fr/pt-br/blog/erros-eas-submit-ios-como-corrigir). Se a chave não estiver comprometida, prepare a nova antes de cortar a antiga. Se estiver, a Apple pede para revogá-la imediatamente.

Para a sua própria chave individual: seu perfil, Individual API Key e depois Revoke.

## Meu checklist da chave .p8

- O Account Holder pediu acesso à API.
- A chave é de equipe se for usada para builds ou perfis.
- A função é a menor que cobre o uso, e o nome diz qual ferramenta a usa.
- O `.p8` está guardado fora do repositório, com permissões restritas e uma cópia de backup criptografada.
- O Issuer ID e o Key ID estão anotados à parte, sem o arquivo.
- Cada ferramenta tem a sua chave, para poder revogar só uma.

## Automatizar sua publicação sem expor sua chave

A chave é só uma peça do caminho. O [iOS & Android Kit](https://devoria.fr/pt-br/kits/ios) parte do código inicial dos meus apps, com assinaturas incluídas, e segue quatro etapas até a App Store, no seu ritmo. Se você conectar o RevenueCat com essa chave, a configuração completa está em [RevenueCat e assinatura in-app no iOS](https://devoria.fr/pt-br/blog/revenuecat-assinatura-in-app-ios).

Se você está preparando o seu primeiro lançamento, [faça o seu diagnóstico gratuito](https://devoria.fr/pt-br/diagnostic): ele mostra o que realmente está te travando e te envia o meu checklist anti-rejeição da Apple. A página [publicar um aplicativo na App Store](https://devoria.fr/pt-br/expertise/publicar-app-na-app-store) retoma cada etapa, da página na loja até a aprovação.

## Perguntas frequentes

### Como criar uma chave API App Store Connect?

O Account Holder pede primeiro acesso à API. Depois, um Admin abre Users and Access, aba Integrations, App Store Connect API, Team Keys. Ele clica em Generate API Key, escolhe um nome e uma função, gera a chave e baixa o arquivo `.p8`.

### Dá para baixar de novo uma chave .p8 perdida?

Não. O arquivo só pode ser baixado uma vez, e a Apple não guarda nenhuma cópia. Revogue a chave perdida, gere uma nova e atualize cada ferramenta que a usava.

### Onde encontrar o Issuer ID e o Key ID?

No App Store Connect, menu Users and Access, aba Integrations. O Issuer ID aparece no topo da página. O Key ID está na lista de chaves ativas. Uma chave individual não usa Issuer ID.

### Qual função dar a uma chave usada pela Expo?

O guia da Expo indica a função Admin. Segundo a tabela de funções da Apple, App Manager basta para enviar builds e criar certificados e perfis. É a função da minha chave, usada nos meus builds Expo.

### Dá para mudar a função de uma chave API?

Não. A Apple não permite alterar nem o nome nem a função de uma chave depois de criada. Revogue a chave e gere uma nova com a função certa.

### Uma chave API App Store Connect expira?

As páginas da Apple não mencionam nenhuma expiração da chave, só a revogação. Quem expira são os tokens assinados com ela, em no máximo 20 minutos para a maioria das requisições.


## Seu projeto

[Review Kit](https://devoria.fr/pt-br/kits/app-review): Meu checklist de revisão da App Store, as recusas da Apple que corrigi, o checklist do Google Play e três skills do Claude Code. R$ 289.

[iOS & Android Kit](https://devoria.fr/pt-br/kits/ios): Crie seu app para iPhone e Android com o Claude Code: o código inicial dos meus apps, o caminho até as lojas e todos os kits. R$ 589.

[Diagnóstico: o que te separa do seu app de iPhone](https://devoria.fr/pt-br/diagnostic): 7 perguntas, 60 segundos: descubra o que realmente te impede de publicar seu app de iPhone, seu caminho em 4 etapas e o kit certo para você.