# Chiavi API Utilizza le chiavi API per autenticare le richieste API. Stripe autentica le richieste API utilizzando le chiavi API del tuo account. Se una richiesta non include una chiave valida, Stripe restituisce un [errore di richiesta non valida](https://docs.stripe.com/error-handling.md#invalid-request-errors). Se una richiesta include una chiave eliminata o scaduta, Stripe restituisce un [errore di autenticazione](https://docs.stripe.com/error-handling.md#authentication-errors). Utilizza la [Dashboard per sviluppatori](https://dashboard.stripe.com/test/apikeys) per creare, rivelare, eliminare e ruotare le chiavi API. Puoi accedere alle chiavi API v1 nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys). > #### Se sei un nuovo utente di Stripe > > - **Proteggi la tua attività:** leggi le nostre [best practice](https://docs.stripe.com/keys-best-practices.md) per la gestione delle chiavi. - **Creazione e test**: utilizza le tue *chiavi sandbox (modalità di test)*. Le chiavi sandbox iniziano con `pk_test_` (pubblicabile), `rk_test_` (con limitazioni), e `sk_test_` (segreta). Ti consentono di effettuare dei test senza influire sui dati effettivi. - **Quando è tutto pronto per accettare pagamenti reali?** Passa alle tue **chiavi in modalità live**, che iniziano con `pk_live_`, `rk_live_` e `sk_live_`. Per istruzioni, consulta [Passaggio alla modalità live](https://docs.stripe.com/keys.md#switch-to-live-mode). - **Se hai bisogno di una chiave privata di firma webhook**: le chiavi private webhook sono separate dalle chiavi API. Le trovi nella sezione [Webhook](https://dashboard.stripe.com/webhooks) della Dashboard sotto ogni endpoint webhook. ## Tipi di chiave Stripe supporta diversi tipi di chiavi API per diversi casi d’uso. È tua responsabilità gestire queste chiavi in modo sicuro. In particolare, considera le chiavi private e le [chiavi API con limitazioni](https://docs.stripe.com/keys/restricted-api-keys.md) (RAK) come dati sensibili e non divulgarle al di fuori del tuo ambiente server. Per garantire la sicurezza della tua attività, leggi e comprendi le [best practice per la gestione delle chiavi API private](https://docs.stripe.com/keys-best-practices.md). Sviluppa e [testa](https://docs.stripe.com/testing.md) la tua applicazione utilizzando chiavi sandbox, chiavi non in modalità live, per assicurarti di non modificare accidentalmente gli addebiti o i clienti live. | Tipo | Sicuro da esporre | Generato per impostazione predefinita | Descrizione | | ----------------------------------------------------------- | ----------------- | ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Chiave privata sandbox`sk_test_` | No | Sì | Autentica le richieste sul tuo server quando sei in modalità live. Per impostazione predefinita, puoi utilizzare questa chiave per eseguire qualsiasi richiesta API senza limitazioni. | | Chiave API sandbox con limitazioni (RAK)`rk_test_` | No | No | È come una chiave privata, ma con autorizzazioni API Stripe che puoi gestire autonomamente. Puoi utilizzare diverse RAK in diverse parti del tuo codice per adattare con precisione le autorizzazioni ai componenti dell’app. Utilizza una RAK in modalità sandbox per mettere a punto le autorizzazioni API Stripe della tua app prima di creare RAK in modalità live. | | Chiave sandbox pubblicabile`pk_test_` | Sì | Sì | Testa le richieste nel codice lato client della tua app web o del dispositivo mobile. | | Chiave privata in modalità live`sk_live_` | No | Sì | Autentica le richieste sul tuo server quando sei in modalità live. Per impostazione predefinita, puoi utilizzare questa chiave per eseguire qualsiasi richiesta API senza limitazioni. | | Chiave API con limitazioni in modalità live (RAK)`rk_live_` | No | No | Assegna autorizzazioni personalizzate ai componenti lato server per garantire che ogni parte della tua app disponga esattamente delle autorizzazioni API Stripe di cui ha bisogno. L’uso di una chiave RAK al posto di una chiave privata limita il rischio di danni nel caso in cui una chiave venga accidentalmente divulgata o la tua app venga compromessa. | | Chiave pubblicabile in modalità live`pk_live_` | Sì | Sì | Quando è tutto pronto per avviare la tua app, usa questa chiave nel codice lato client della tua app web o per dispositivo mobile. | Trova le tue [chiavi API](https://dashboard.stripe.com/apikeys) nella Dashboard Stripe. Se non riesci a visualizzare le chiavi API ma devi gestire le chiavi per la tua app, chiedi al titolare del tuo account Stripe di aggiungerti al suo [team](https://docs.stripe.com/get-started/account/teams.md) con le autorizzazioni appropriate. Se hai effettuato l’accesso a Stripe, la nostra documentazione include le tue chiavi API di test in alcuni punti per illustrare l’utilizzo delle API. Solo tu puoi vedere questi valori. Se non hai effettuato l’accesso, i nostri esempi di codice includono chiavi API generate casualmente. > #### Segreti di firma webhook > > I segreti di firma dei webhook non sono chiavi API: si tratta di segreti specifici per ciascun webhook che il destinatario del webhook utilizza per verificare che i webhook provengano effettivamente da Stripe. Puoi trovare il segreto di firma per ciascun endpoint webhook nella sezione [Webhook](https://dashboard.stripe.com/webhooks) della Dashboard. ## Proteggi le tue chiavi Chiunque può utilizzare la tua chiave privata in modalità live per effettuare qualsiasi chiamata API a nome del tuo account, ad esempio per creare un addebito o effettuare un rimborso. *Hai la responsabilità della sicurezza delle tue chiavi*. Proteggi le tue chiavi seguendo queste best practice: - Conserva le chiavi segrete in un archivio segreto o in variabili ambientali crittografate. Non conservare le chiavi nel codice sorgente o nei file di configurazione sottoposti a controllo di versione. - Usa [chiavi API con limitazioni](https://docs.stripe.com/keys.md#create-restricted-api-secret-key) anziché chiavi private quando possibile. Le chiavi con limitazioni limitano l’accesso solo alle risorse sull’API specifiche di cui la tua integrazione ha bisogno, riducendo l’impatto di una chiave compromessa. - [Limita le chiavi a indirizzi IP](https://docs.stripe.com/keys.md#limit-api-secret-keys-ip-address) specifici in modo che possano essere utilizzate solo dai tuoi server noti. - [Sostituisci le chiavi](https://docs.stripe.com/keys.md#rolling-keys) quando i membri del team che hanno accesso alle chiavi lasciano la tua organizzazione. - Non condividere le chiavi via email, chat o altri canali non crittografati. Per ulteriori dettagli, consulta le [best practice per la gestione delle chiavi API private](https://docs.stripe.com/keys-best-practices.md). ## Sandbox e modalità live a confronto Tutte le richieste API di Stripe vengono eseguite in *sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes) o in *modalità live* (Use this mode when you’re ready to launch your app. Card networks or payment providers process payments). Puoi utilizzare una sandbox per accedere ai dati di prova e la modalità live per accedere ai dati effettivi dell’account. Ciascuna modalità dispone di una propria serie di chiavi API e gli oggetti di una modalità non sono accessibili dall’altra. Ad esempio, un [oggetto di prodotto](https://docs.stripe.com/api/products/object.md) sandbox non può far parte di un pagamento in modalità live | Modalità | Prefisso chiave | Finalità | | ----------------- | ---------------------------------- | ----------------------------------------------------------------------------------------------- | | Sandbox (di test) | `pk_test_`, `sk_test_`, `rk_test_` | Crea e testa la tua integrazione in tutta sicurezza. Non ti verrà addebitato alcun costo reale. | | Live | `pk_live_`, `sk_live_`, `rk_live` | Accetta pagamenti reali da clienti reali. | > #### Accesso alla chiave in modalità live > > Puoi rivelare una chiave API privata o con limitazioni in modalità live solo una volta. Se la perdi, non puoi recuperarla dalla Dashboard. In tal caso, devi ruotarla o eliminala e quindi creane una nuova. | Tipo | Quando si usano | Oggetti | Come si usano | Considerazioni | | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Sandbox | Utilizza una sandbox e le chiavi API di test associate mentre crei la tua integrazione. In una sandbox, i circuiti delle carte di credito e i fornitori di servizi di pagamento non elaborano i pagamenti. | Le chiamate API restituiscono oggetti simulati. Ad esempio, puoi recuperare e utilizzare gli oggetti test `account`, `payment`, `customer`, `charge`, `refund`, `transfer`, `balance` e `subscription`. | Utilizza [account e carte di credito di test](https://docs.stripe.com/testing.md#cards). Non puoi accettare metodi di pagamento reali né lavorare con account reali. | [Identy](https://docs.stripe.com/identity.md) non effettua alcuna verifica. Inoltre, gli [oggetti Account](https://docs.stripe.com/api/accounts/object.md) di Connect non restituiscono campi sensibili. | | Modalità live | Utilizza la modalità live, e le chiavi API live associate, quando sarà tutto pronto per lanciare l’integrazione e accettare denaro reale. In modalità live, i circuiti delle carte di credito e i fornitori di servizi di pagamento elaborano i pagamenti. | Le chiamate API restituiscono oggetti reali. Ad esempio, puoi recuperare e utilizzare gli oggetti reali `account`, `payment`, `customer`, `charge`, `refund`, `transfer`, `balance` e `subscription`. | Accetta carte di credito reali e lavora con gli account dei clienti. Puoi accettare autorizzazioni di pagamento, addebiti e acquisizioni reali per carte di credito e account. | Il flusso delle contestazioni è più dettagliato e la relativa [procedura di test](https://docs.stripe.com/testing.md#disputes) è più semplice. Inoltre, alcuni [metodi di pagamento](https://docs.stripe.com/payments/payment-methods.md) hanno un flusso più dettagliato e richiedono un maggior numero di passaggi. | ## Passa alla modalità live Quando è tutto pronto per accettare pagamenti reali, utilizza le chiavi API in modalità live anziché quelle in modalità sandbox (di prova). Nella pagina delle [chiavi API](https://dashboard.stripe.com/apikeys), passa dalla **modalità sandbox** alla **modalità live**. La pagina ora mostra le tue chiavi API in modalità live. ### Chiavi pubblicabili (lato client) 1. Copia la tua **chiave pubblicabile in modalità live** (inizia con `pk_live_`) e sostituisci la chiave `pk_test_` nel codice lato client. ### Chiavi API con limitazioni o private (lato server) Le chiavi API lato server sono dati sensibili; pertanto, se non l’hai ancora fatto, ti invitiamo a consultare le nostre [best practice per la gestione delle chiavi API private](https://docs.stripe.com/keys-best-practices.md). Ti consigliamo di generare [chiavi API con limitazioni](https://docs.stripe.com/keys/restricted-api-keys.md) per il tuo codice lato server, in modo da limitare i danni alla tua attività nel caso in cui le chiavi venissero divulgate o compromesse. 1. Prima di iniziare a utilizzare una chiave in modalità live nella tua applicazione back-end, rimuovi dal codice eventuali chiavi API private (o con limitazioni) hardcoded. Utilizza invece un repository di segreti o una variabile d’ambiente per fornire la chiave sandbox e verifica che l’applicazione funzioni ancora correttamente. 1. Rivela e copia le tue **chiavi in modalità live** (inizia con `rk_live_` o `sk_live_`) e memorizzale in modo sicuro nel tuo ambiente server. Fai attenzione: puoi visualizzare ogni chiave privata o con limitazioni in modalità live solo una volta. 1. Configura il tuo ambiente server per fornire chiavi in modalità live anziché chiavi sandbox alla tua richiesta di registrazione. 1. Se utilizzi i webhook, aggiorna l’URL di ciascun endpoint webhook e copia la nuova **chiave privata di firma** dalla sezione [Webhook](https://dashboard.stripe.com/webhooks) della Dashboard. > #### Lista di controllo completa per l'attivazione del servizio > > Cambiare chiave API è solo un passaggio. Rivedi la [checklist live](https://docs.stripe.com/get-started/checklist/go-live.md) completa per assicurarti che la tua integrazione sia pronta per la produzione. ## Chiavi private e con limitazioni Usa la Dashboard per creare, rivelare, modificare, eliminare e ruotare chiavi private e con limitazioni. ### Creare una chiave API Consiglia agli utenti di creare RAK, anziché chiavi private. L’uso di chiavi private può aggravare le conseguenze di una violazione. - Consigliamo di creare [chiavi API con limitazioni](https://docs.stripe.com/keys/restricted-api-keys.md) (RAK) per la maggior parte dei casi d’uso. Utilizzando una RAK, puoi assegnare esattamente le autorizzazioni necessarie alla tua integrazione, riducendo così i danni che un malintenzionato potrebbe causare alla tua attività qualora entrasse in possesso della tua chiave. Crea una chiave API privata senza limitazioni solo quando la tua integrazione richiede l’accesso a tutte le API e alle risorse di Stripe. #### Per creare una chiave API con limitazioni 1. Nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys), esegui una delle seguenti operazioni: - Per creare una nuova chiave con limitazioni, fai clic su **Crea chiave con limitazioni**. Il valore predefinito per tutte le autorizzazioni è **Nessuna**. - Per clonare una chiave esistente, fai clic sul menu di overflow (⋯), quindi seleziona **Duplica chiave** per la chiave che vuoi clonare. Il valore predefinito per ogni autorizzazione è il relativo valore nella chiave clonata. 1. Nel campo **Nome chiave**, inserisci un nome. Se è stata clonata una chiave esistente, il nome predefinito corrisponde al nome della chiave clonata. 1. Per ogni risorsa a cui desideri che la nuova chiave abbia accesso, seleziona l’autorizzazione appropriata: **Nessuna**, **Lettura** o **Scrittura**. Se utilizzi Connect, puoi anche selezionare l’autorizzazione da consentire a questa chiave quando accedi agli account connessi. 1. Fai clic su **Crea chiave**. 1. Nella finestra di dialogo inserisci il codice di verifica che Stripe ti invia via email o SMS. Se la finestra di dialogo non continua automaticamente, fai clic su **Continua**. 1. Fai clic sul valore chiave per copiarlo. 1. Salva il valore della chiave. Non potrai più recuperarlo. 1. Nel campo **Aggiungi una nota**, inserisci la posizione in cui hai salvato la chiave e fai clic su **Fine**. #### Per creare una chiave API privata 1. Nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys), fai clic su **Crea chiave privata**. 1. Nella finestra di dialogo inserisci il codice di verifica che Stripe ti invia via email o SMS. Se la finestra di dialogo non continua automaticamente, fai clic su **Continua**. 1. Inserisci un nome nel campo **Nome chiave**, quindi fai clic su **Crea**. 1. Fai clic sul valore chiave per copiarlo. 1. Salva il valore della chiave. Non potrai più recuperarlo. 1. Nel campo **Aggiungi una nota**, inserisci la posizione in cui hai salvato la chiave e fai clic su **Fine**. ### Rivelare una chiave API Puoi rivelare una chiave API privata o con limitazioni in una sandbox o in modalità live. In modalità live, Stripe mostra ogni chiave API con limitazioni o privata una sola volta. Conserva la chiave in un luogo sicuro, ma non nel codice della tua applicazione. Per ricordarti dove l’hai salvata, puoi aggiungere una nota alla chiave nella Dashboard. Se perdi la chiave, puoi sostituirla o eliminarla e crearne un’altra. > #### Rivelare chiavi private in modalità live > > Quando crei una chiave API privata o con limitazioni in modalità live, viene visualizzata prima che la salvi. Devi copiare la chiave prima di salvarla perché potrai copiarla in un secondo momento. Puoi rivelare solo una chiave privata predefinita o una chiave generata tramite rotazione programmata. #### Rivelare una chiave API privata o con limitazioni in modalità live 1. Nella scheda [Chiavi API](https://dashboard.stripe.com/apikeys) in modalità live, nell’elenco **Chiavi standard** o **Chiavi con limitazioni**, fai clic su **Rivela chiave live** per la chiave che desideri rivelare. 1. Fai clic sul valore chiave per copiarlo. 1. Salva il valore della chiave in un luogo sicuro, come il vault delle chiavi private della tua piattaforma o la configurazione della variabile di ambiente back-end. 1. Fai clic su **Nascondi chiave di test**. 1. Clicca sul menu di overflow (⋯), quindi seleziona **Modifica chiave** per la chiave a cui desideri aggiungere una nota. 1. Nel campo **Nota** inserisci la posizione in cui hai salvato la chiave, poi fai clic su **Salva**. > Le chiavi create prima che Stripe introducesse questa funzione non vengono nascoste automaticamente quando vengono rivelate. È necessario nasconderle manualmente facendo clic su **Nascondi chiave attiva**. ### Limitare una chiave API a determinati indirizzi IP Puoi limitare una chiave API privata o una chiave API con limitazioni a un intervallo di indirizzi IP o a uno o più indirizzi IP specifici. Stripe consiglia di abilitare le limitazioni IP su tutte le chiavi in modalità live per impedire l’uso da posizioni non autorizzate. Se applicabile, utilizza elenchi di consenso IP separati per chiavi separate (ad esempio, per distinguere tra ambienti di staging e di produzione). Gli indirizzi IP devono utilizzare il protocollo IPv4 e puoi specificare qualsiasi intervallo CIDR valido. Ad esempio,puoi specificare l’intervallo `100.10.38.0 - 100.10.38.255` come `100.10.38.0/24`. Tutti gli indirizzi IP nell’intervallo devono iniziare con `100.10.38`. 1. Nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys), nell’elenco **Chiavi Standard** o **Chiavi con limitazioni**, fai clic sul menu di overflow (⋯) e seleziona la chiave che vuoi rivelare. 1. Seleziona **Gestisci limitazioni IP** > **Limita l’uso a una serie di indirizzi IP**. 1. Esegui una delle seguenti operazioni: - Inserisci uno o più indirizzi IP nel campo **Indirizzo IP**. - Per un intervallo di indirizzi IP, inserire il primo indirizzo dell’intervallo (utilizzando la notazione CIDR, routing interdominio senza classi) nel campo **Indirizzo IP**. Inserisci la dimensione del prefisso di rete nel campo **CIDR**. 1. Per aggiungere un altro indirizzo IP o intervallo, fai clic su **+ Aggiungi**. 1. Fai clic su **Salva**. ### Modificare il nome o la nota di una chiave API 1. Nella scheda delle [chiavi API](https://dashboard.stripe.com/test/apikeys), fai clic sul menu di overflow (⋯) della chiave che vuoi modificare. 1. Seleziona **Modifica chiave**. 1. Procedi come segue: - Per modificare il nome, inserisci un nuovo nome nel campo **Nome chiave**. - Per modificare il testo della nota, inserisci il nuovo testo nel campo **Nota**. 1. Fai clic su **Salva**. ### Fai scadere una chiave API Se elimini una chiave API privata o una chiave API con limitazioni, devi crearne una nuova e aggiornare tutti i codici che utilizzano la chiave scaduta. Ogni codice che utilizza la chiave scaduta non potrà più effettuare chiamate API. > Non puoi far scadere una chiave pubblicabile. 1. Nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys), nell’elenco **Chiavi Standard** o **Chiavi con limitazioni**, fai clic sul menu di overflow (⋯) della chiave che desideri far scadere. 1. Seleziona **Scadenza chiave**. 1. Nella finestra di dialogo, fai clic su **Elimina chiave**. Se non vuoi più eliminarla, fai clic su **Annulla**. ### Ruotare una chiave API La rotazione di una chiave API la revoca e genera una chiave sostitutiva pronta da usare subito. Puoi anche possibile programmare la rotazione di una chiave API dopo un determinato periodo di tempo. La chiave sostitutiva viene denominata come segue: - Il nome della chiave pubblicabile sostitutiva è sempre `Publishable key`. - Il nome chiave privata sostitutiva è sempre `Secret key`. - La chiave con limitazioni sostitutiva ha lo stesso nome della chiave ruotata. Puoi rinominare una chiave API privata, o con limitazioni, modificandola. Ruota la chiave API in scenari come: - Se perdi una chiave API privata, o con limitazioni, in modalità live e non puoi recuperarla dalla Dashboard. - Se una chiave API privata o con limitazioni viene compromessa, è necessario revocarla per bloccare eventuali richieste API potenzialmente dannose che potrebbero utilizzare la chiave. - Se un membro del team con accesso alla chiave lascia la tua organizzazione o cambia ruolo. - Se la tua policy richiede la rotazione delle chiavi a determinati intervalli. #### Per ruotare una chiave API: 1. Nella scheda delle [chiavi API](https://dashboard.stripe.com/test/apikeys), fai clic sul menu extra (⋯) della chiave che vuoi ruotare. 1. Seleziona **Ruota chiave**. 1. Seleziona una data di scadenza dal menu a discesa **Scadenza**. Se selezioni **Ora**, la chiave precedente viene eliminata. Se specifichi un’ora, sotto il nome della chiave viene mostrato il tempo rimanente fino alla scadenza della chiave. 1. Fai clic su **Ruota chiave API**. 1. Fai clic sul valore chiave per copiarlo. 1. Salva il valore della chiave. Non potrai più recuperarlo. 1. Nel campo **Aggiungi una nota** inserisci la posizione in cui hai salvato la chiave, quindi fai clic su **Salva** o **Fine**. ### Ripristina l’accesso a una chiave API Una chiave API può avere un accesso limitato se non è stato utilizzata per creare trasferimenti, bonifici o aggiornare destinazioni di bonifico per oltre 180 giorni. Non è possibile utilizzare una chiave con accesso limitato per creare bonifici e trasferimenti o per creare destinazioni di bonifico. È possibile ripristinare l’accesso per utilizzare il codice normalmente o per eseguire un’azione bloccata. #### Per ripristinare l’accesso per una chiave API 1. Nella scheda delle [chiavi API](https://dashboard.stripe.com/test/apikeys), fai clic sul menu extra (⋯) della chiave che vuoi ripristinare. 1. Seleziona **Ripristina accesso**. 1. Fai clic su **Ripristina**. ## Chiavi API dell’organizzazione Se hai più account business Stripe in un’[organizzazione](https://docs.stripe.com/get-started/account/orgs.md), puoi configurare una singola chiave API a livello di organizzazione. Le chiavi API a livello di organizzazione offrono le seguenti funzionalità: - **Accesso a qualsiasi account**: utilizza le chiavi API dell’organizzazione per accedere alle risorse di qualsiasi account all’interno dell’organizzazione. - **Autorizzazioni con limitazioni**: limita le chiavi API dell’organizzazione per concedere l’autorizzazione di lettura o scrittura solo a risorse specifiche. - **Gestione centralizzata**: crea e gestisci le chiavi API dell’organizzazione nella scheda [Chiavi API](https://dashboard.stripe.com/org/api-keys/secret) della Dashboard dell’organizzazione. ### Comportamento Le chiavi API dell’organizzazione si comportano in modo diverso dalle chiavi API a livello di account, ad esempio: - Non dispongono di una chiave pubblicabile. Tratta tutte le chiavi API dell’organizzazione come chiavi private. - Hanno tutti lo stesso prefisso `sk_org`, indipendentemente dai loro livelli di autorizzazione. - Tutte le richieste API effettuate con una chiave API dell’organizzazione devono includere l’intestazione `Stripe-Context` per identificare l’account interessato. - tutte le richieste API effettuate con una chiave API dell’organizzazione devono includere l’intestazione `Stripe-Version` per garantire coerenza e prevedibilità tra le integrazioni dell’organizzazione. ### Utilizzare le chiavi API dell’organizzazione Quando utilizzi una chiave API dell’organizzazione, devi anche rispettare le condizioni seguenti: - Specifica una versione dell’API includendo un’intestazione `Stripe-Version`. Quando usi un [SDK Stripe](https://docs.stripe.com/sdks/set-version.md), l’SDK imposta automaticamente la versione dell’API. - Identifica l’account interessato dalla richiesta API includendo l’intestazione `Stripe-Context`. Ad esempio, data la seguente struttura dell’organizzazione: ``` Organization (org_6SD3oI0eSQemPzdmaGLJ5j6) ├── Platform account (acct_1R3fqDP6919yCiFv) | └── Connected account (acct_1032D82eZvKYlo2C) └── Standalone account (acct_1aTnTtAAB0hHJ26p) ``` Puoi utilizzare la chiave API dell’organizzazione per accedere al saldo dell’account indipendente. Puoi utilizzare la stessa chiave anche per effettuare la stessa chiamata per l’account connesso della piattaforma. ```curl curl https://api.stripe.com/v1/balance \ -u {{ORG_SECRET_KEY}}: \ -H "Stripe-Version: {{STRIPE_API_VERSION}}" \ -H "Stripe-Context: {{CONTEXT_ID}}" ``` Nell’esempio di codice precedente, sostituisci `{{CONTEXT}}` con il valore pertinente: - Per l’account indipendente, utilizza `acct_1aTnTtAAB0hHJ26p`. - Per l’account connesso, utilizza un percorso che identifichi sia la piattaforma che l’account connesso, seguendo il formato `acct_1R3fqDP6919yCiFv/acct_1032D82eZvKYlo2C`. È necessario specificare l’account pertinente utilizzando il contesto e la versione API in qualsiasi richiesta API che utilizza una chiave dell’organizzazione. Le organizzazioni non dispongono di chiavi API pubblicabili perché non possono accettare pagamenti. Puoi utilizzare la chiave API dell’organizzazione per creare un PaymentIntent per qualsiasi account dell’organizzazione, ma devi utilizzare chiavi pubblicabili specifiche dell’account esistente per le operazioni lato client. ## Chiavi API gestite Alcune piattaforme di terze parti, come [Vercel](https://vercel.com/docs/integrations/ecommerce/stripe), possono creare e gestire chiavi API per tuo conto quando installi la loro integrazione. Queste chiavi sono chiamate chiavi API gestite e la piattaforma le crea tramite codice anziché manualmente nella Dashboard. Le chiavi API gestite vengono visualizzate insieme alle altre chiavi nella scheda [Chiavi API](https://dashboard.stripe.com/test/apikeys), con il nome della piattaforma di gestione. La tabella seguente riassume le differenze tra chiavi non gestite e chiavi gestite. | | Chiavi non gestite | Chiavi gestite | | ------------------------ | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | | Creazione chiave | Crea chiavi nella Dashboard | La piattaforma crea chiavi utilizzando l’API | | Interazione con l’utente | Copia le chiavi dalla Dashboard e configurale nella piattaforma | La piattaforma gestisce automaticamente la configurazione delle chiavi | | Consegna chiavi | Visualizzate nella Dashboard | Consegnate direttamente alla piattaforma | | Gestione delle chiavi | Controlli rotazione e scadenza | La piattaforma gestisce il ciclo di vita delle chiavi; puoi farle scadere in qualsiasi momento | ### Revoca l’accesso alla chiave gestita Puoi revocare una chiave API gestita in qualsiasi momento effettuando una delle seguenti operazioni: - **Scadenza della chiave**: nella scheda [chiavi API](https://dashboard.stripe.com/apikeys), fai clic sul menu extra (⋯) della chiave gestita e fai clic su di essa per farla scadere. In questo modo viene revocato immediatamente l’accesso alla piattaforma senza rimuovere l’integrazione. - **Disinstalla l’integrazione**: disinstalla l’app della piattaforma dal tuo account Stripe. Quando disinstalli un’app, puoi far scadere immediatamente le chiavi gestite o mantenerle attive. ## Visualizzare log di richieste API Per [aprire i log di richieste API](https://docs.stripe.com/development/dashboard/request-logs.md), fai clic sul menu di overflow (⋯) di qualsiasi chiave, quindi seleziona **Visualizza log richieste**. L’apertura dei registri reindirizza alla Dashboard Stripe. ## See also - [Best practice per la gestione di chiavi API private](https://docs.stripe.com/keys-best-practices.md) - [Protezione dalle chiavi API compromesse](https://support.stripe.com/questions/protecting-against-compromised-api-keys) - [Perché la mia chiave API ha accesso limitato](https://support.stripe.com/questions/why-does-my-api-key-have-limited-access)