> ## Documentation Index > Fetch the complete documentation index at: https://docs.didit.me/llms.txt > Use this file to discover all available pages before exploring further. # Credenziali API: client_id e chiave API > Ottieni client_id e chiave API della tua applicazione Didit. Usa la chiave API nell'header x-api-key per tutte le chiamate. Prezzi a consumo. Prompt per ottenere le credenziali dell'applicazione Copia il prompt negli appunti \

\`Read one application's full record — including its client_id and api_key (client_secret). Use this to RECOVER an api_key you've misplaced.

Endpoint:
GET https://apx.didit.me/auth/v2/organizations/me/{org_id}/applications/{app_id}/

Authentication:
Authorization: Bearer 
Get a token via POST /programmatic/login/.

Path parameters:
\- org_id (UUID, required) — Organization that owns the application. Get via GET /organizations/me/.
\- app_id (UUID, required) — Application UUID. Returned by POST /programmatic/verify-email/ (in the application.uuid field), by POST /organizations/me/{org_id}/applications/, or visible in the Didit console.

curl example:
curl "https://apx.didit.me/auth/v2/organizations/me//applications//" \
-H "Authorization: Bearer "

Response (200 OK):
\{
"uuid": "b2c3d4e5-6789-...",
"name": "My App",
"client_id": "S9LIYGSoWNuGMLHsvEt9dQ",
"api_key": "sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"website_url": "https://example.com",
"redirect_uris": ["https://example.com/callback"],
"terms_url": "https://example.com/terms",
"privacy_url": "https://example.com/privacy",
"description": "Production application",
"created_at": "2025-06-01T10:00:00Z",
"data_location": "eu",
"products": [
\{ "product": "identity", "status": "enabled", "modules": { "user_verification": true, "business_verification": true, "case_management": true } },
\{ "product": "transactions", "status": "disabled", "modules": { "travel_rule": true, "case_management": true } },
\{ "product": "authentication", "status": "disabled", "modules": {} }
]
}

How to use the response:
\- api_key → set as the x-api-key header on EVERY call to https://verification.didit.me/v3/... (sessions, workflows, questionnaires, AML monitoring, billing, etc.).
\- client_id → shown alongside api_key for OAuth-style introspection scenarios. Routine verification calls only need api_key.
\- data_location → where the application's verification data is stored and processed: "eu" (European Union, Ireland). Chosen when the application is created; "au" (Australia, Sydney) and "mx" (Mexico) are coming soon.
\- products → read-only. Always all three products in this order: identity, transactions, authentication. Each has a status (enabled, early_access or disabled) and its module switches (true or false). identity modules: user_verification, business_verification, case_management. transactions modules: travel_rule, case_management. authentication has none ({}).

Failure modes:
\- 401: { "detail": "Invalid access token" } or { "detail": "Expired access token" } when the token is malformed or expired.
\- 403: { "detail": "Only organization owners and admins can manage applications." } when you are a member of the organization but not an owner or admin.
\- 403: { "detail": "Your access to this organization is suspended." } when your membership in the organization is suspended.
\- 403: { "detail": "You do not have permission to perform this action." } when the request has no Authorization header.
\- 404: { "detail": "Organization not found." } when the organization does not exist or you are not a member of it, or { "detail": "Application not found." } when the application is not in that organization.

When to call:
\- After programmatic login from a new machine — you have an access_token but not the api_key, and you need x-api-key to start calling verification.didit.me.
\- Auditing your applications — list all apps with GET /organizations/me/{org_id}/applications/, then read each.

Note:
This endpoint does not rotate the credential. It returns the application's current api_key on every GET, so there is no "show api_key once" model.

For end-to-end Didit integration, paste in the full prompt at /integration/integration-prompt.`

\
Incolla in ## OpenAPI ````yaml it/openapi-auth.json GET /organizations/me/{org_id}/applications/{app_id}/ openapi: 3.0.0 info: version: 1.0.0 title: Didit Auth API description: >- API di registrazione e autenticazione programmatica per sviluppatori e agenti AI. Registrati in 2 chiamate API -- senza bisogno di browser. La piattaforma di verifica dell'identità più adatta agli agenti. ## Base URL Tutti gli endpoint di questa specifica sono ospitati su `https://apx.didit.me/auth/v2`. Si tratta di un host diverso rispetto a quello dell'API di verifica (`https://verification.didit.me/v3`). Distinguili chiaramente: questo host di autenticazione rilascia i tuoi **token di accesso JWT** e ti consente di elencare e gestire le tue **organizzazioni** e le tue **applicazioni**. L'host di verifica è il luogo in cui chiami sessioni, workflow, AML, ecc., autenticandoti con la **`api_key`** restituita da questa API. ## Come funziona il flusso di autenticazione 1. `POST /programmatic/register/` — invia email + password. 2. Ricevi un codice alfanumerico di 6 caratteri via email. 3. `POST /programmatic/verify-email/` — invia il codice. Ricevi in risposta un `access_token` JWT, un `refresh_token`, un'organizzazione e un'applicazione predefinita con `client_id` + `api_key`. 4. Salva la `api_key`. Usala come `x-api-key` per ogni chiamata a `https://verification.didit.me/v3/...`. 5. Da qualsiasi macchina in futuro, `POST /programmatic/login/` scambia email + password con un nuovo JWT, quindi chiama `GET /organizations/me/` e gli endpoint dell'applicazione per recuperare o ruotare le credenziali. Il JWT serve solo per gli endpoint di **Gestione dell'account** in questa specifica; il traffico dell'API di verifica utilizza la `api_key` a lunga durata, non il JWT. ## Convenzioni - Tutti i corpi di richiesta e risposta sono in formato JSON (`Content-Type: application/json`). - **Usa un indirizzo email reale e recapitabile quando testi `POST /programmatic/register/`.** L'endpoint invia il codice di verifica in modo sincrono, quindi gli indirizzi su domini di test riservati (`@example.com`, `@example.org`, `@*.test`, `@*.example`, `@*.invalid`) vengono rifiutati dalla consegna della posta e la richiesta restituisce `500`. Sostituisci il segnaposto `you@yourdomain.com` negli esempi con una casella di posta che puoi effettivamente consultare. - Gli errori di validazione restituiscono HTTP `400` con una delle due strutture: `{"field": ["message", ...]}` per problemi a livello di campo, oppure `{"detail": "message"}` per errori legati a regole aziendali. Alcuni validatori (robustezza della password in fase di registrazione, scadenza del codice su verify-email) attualmente rispondono con un array semplice `["message"]` anziché con il formato indicizzato per campo: si tratta di un'incoerenza nota lato server, pertanto il codice client dovrebbe accettare entrambi i formati. - Gli errori di autenticazione vengono restituiti come `{"detail": "..."}` con HTTP `401` (token bearer non valido) o `403` (token bearer mancante / autorizzazioni insufficienti). - Le risposte relative al limite di frequenza includono un campo `wait` con il tempo di attesa in secondi. servers: - url: https://apx.didit.me/auth/v2 description: Server di autenticazione di produzione security: [] tags: - name: Programmatic Auth description: >- Ciclo di vita dell'account basato su email e password: registrazione, verifica, accesso. Restituisce il JWT `access_token` utilizzato per gli endpoint di gestione dell'account, oltre a (in fase di verifica) `client_id` e `api_key` della tua prima applicazione. - name: Account Management description: >- Endpoint autenticati (bearer JWT) che elencano le organizzazioni e creano, recuperano o aggiornano le applicazioni. Usali per recuperare o ruotare la `api_key` con cui autentichi le chiamate API di verifica. paths: /organizations/me/{org_id}/applications/{app_id}/: get: tags: - Account Management summary: Recupera credenziali dell'applicazione description: >- Leggi il record completo di un'applicazione, inclusi `client_id` e `api_key`. Usalo per recuperare una `api_key` smarrita. operationId: get_application_credentials parameters: - name: org_id in: path required: true description: UUID dell'organizzazione proprietaria dell'applicazione. schema: type: string format: uuid example: a1b2c3d4-5678-90ab-cdef-111111111111 - name: app_id in: path required: true description: UUID dell'applicazione di cui vuoi leggere le credenziali. schema: type: string format: uuid example: b2c3d4e5-6789-01bc-defg-222222222222 responses: '200': description: Record dell'applicazione comprensivo di `client_id` e `api_key`. content: application/json: schema: $ref: '#/components/schemas/Application' examples: Success: value: uuid: b2c3d4e5-6789-01bc-defg-222222222222 name: My App client_id: S9LIYGSoWNuGMLHsvEt9dQ api_key: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx website_url: https://example.com redirect_uris: - https://example.com/callback terms_url: https://example.com/terms privacy_url: https://example.com/privacy description: Production application created_at: '2025-06-01T10:00:00Z' data_location: eu products: - product: identity status: enabled modules: user_verification: true business_verification: true case_management: true - product: transactions status: disabled modules: travel_rule: true case_management: true - product: authentication status: disabled modules: {} '401': description: >- Token di accesso non corretto, non valido o scaduto. Ottienine uno nuovo con `POST /programmatic/login/`. content: application/json: schema: $ref: '#/components/schemas/AuthError' examples: InvalidToken: value: detail: Invalid access token ExpiredToken: value: detail: Expired access token '403': description: >- Non puoi leggere questa applicazione. Un membro dell'organizzazione che non è proprietario o amministratore riceve `Only organization owners and admins can manage applications.` Un proprietario o amministratore il cui accesso all'organizzazione è sospeso riceve `Your access to this organization is suspended.` Una richiesta senza intestazione `Authorization` riceve `You do not have permission to perform this action.` content: application/json: schema: $ref: '#/components/schemas/AuthError' examples: NotOwnerOrAdmin: summary: Membro che non è un proprietario o amministratore value: detail: >- Only organization owners and admins can manage applications. Suspended: summary: Iscrizione sospesa value: detail: Your access to this organization is suspended. MissingToken: summary: Nessuna intestazione Authorization value: detail: You do not have permission to perform this action. '404': description: >- L'organizzazione non esiste o non ne fai parte, oppure l'applicazione non esiste in tale organizzazione. content: application/json: schema: $ref: '#/components/schemas/AuthError' examples: OrganizationNotFound: summary: Organizzazione non trovata, oppure non ne sei membro value: detail: Organization not found. ApplicationNotFound: summary: Nessuna applicazione del genere in questa organizzazione value: detail: Application not found. security: - BearerAuth: [] x-codeSamples: - lang: curl label: cURL source: >- curl "https://apx.didit.me/auth/v2/organizations/me/$ORG_ID/applications/$APP_ID/" \ -H "Authorization: Bearer $ACCESS_TOKEN" - lang: python label: Python source: |- from didit import Didit # Use the access token that account.login returns. client = Didit(account_token="YOUR_ACCESS_TOKEN") result = client.account.applications.retrieve( "a1b2c3d4-5678-90ab-cdef-111111111111", "b2c3d4e5-6789-01bc-defg-222222222222", ) print(result) - lang: javascript label: Node.js source: |- import Didit from "@didit-protocol/sdk-node"; // Use the access token that account.login returns. const didit = new Didit({ accountToken: "YOUR_ACCESS_TOKEN" }); const result = await didit.account.applications.retrieve( "a1b2c3d4-5678-90ab-cdef-111111111111", "b2c3d4e5-6789-01bc-defg-222222222222", ); console.log(result); - lang: go label: Go source: "ctx := context.Background()\n// Use the access token that account.login returns.\nclient := didit.NewClient(option.WithAccountToken(\"YOUR_ACCESS_TOKEN\"))\n\nresult, err := client.Account.Applications.Retrieve(ctx, \"a1b2c3d4-5678-90ab-cdef-111111111111\", \"b2c3d4e5-6789-01bc-defg-222222222222\")\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)" - lang: java label: Java source: >- import me.didit.Didit; // Use the access token that account.login returns. Didit client = Didit.builder().accountToken("YOUR_ACCESS_TOKEN").build(); var result = client.account().applications().retrieve("a1b2c3d4-5678-90ab-cdef-111111111111", "b2c3d4e5-6789-01bc-defg-222222222222"); System.out.println(result); - lang: php label: PHP source: >- account->applications->retrieve('a1b2c3d4-5678-90ab-cdef-111111111111', 'b2c3d4e5-6789-01bc-defg-222222222222'); print_r($result->toArray()); - lang: ruby label: Ruby source: |- require "didit" # Use the access token that account.login returns. didit = Didit::Client.new(account_token: "YOUR_ACCESS_TOKEN") result = didit.account.applications.retrieve( "a1b2c3d4-5678-90ab-cdef-111111111111", "b2c3d4e5-6789-01bc-defg-222222222222" ) puts result.to_h - lang: csharp label: .NET source: >- using System; using System.Text.Json; using Didit; // Use the access token that account.login returns. using var client = new DiditClient(new DiditClientOptions { AccountToken = "YOUR_ACCESS_TOKEN" }); var result = await client.Account.Applications.RetrieveAsync("a1b2c3d4-5678-90ab-cdef-111111111111", "b2c3d4e5-6789-01bc-defg-222222222222"); Console.WriteLine(JsonSerializer.Serialize(result)); components: schemas: Application: type: object description: >- Record completo dell'applicazione. `uuid`, `client_id` e `api_key` non cambiano mai dopo la creazione. Nemmeno `data_location` cambia, tranne una volta sull'applicazione di produzione creata con la tua organizzazione, prima che venga utilizzata (vedi la richiesta di aggiornamento). properties: uuid: type: string format: uuid description: >- UUID dell'applicazione. Da utilizzare come `{app_id}` nelle chiamate successive. example: b2c3d4e5-6789-01bc-defg-222222222222 name: type: string description: Nome visualizzato dell'applicazione mostrato nella console Didit. example: Acme Production App client_id: type: string description: >- Identificatore client pubblico, sicuro da incorporare nei flussi di tipo OAuth. example: S9LIYGSoWNuGMLHsvEt9dQ api_key: type: string description: >- Segreto a lunga durata (chiamato anche `client_secret`). Da usare come intestazione `x-api-key` per ogni chiamata a `https://verification.didit.me/v3/...` (sessioni, workflow, AML, ecc.). Trattalo come una credenziale; non esporlo mai lato client. Le nuove chiavi iniziano con `sk_live_` (applicazione di produzione) o `sk_test_` (applicazione sandbox), seguiti da 43 caratteri URL-safe (lettere, cifre, `-` e `_`). Le chiavi create prima di questo formato non hanno prefisso e continuano a funzionare invariate. Per le 72 ore successive al recupero dell'account, le operazioni di elenco, recupero e aggiornamento restituiscono qui una stringa vuota al posto della chiave. example: sk_live_example_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx website_url: type: string nullable: true description: URL del sito web o dell'app associato a questa applicazione. example: https://acme.example redirect_uris: type: array items: type: string description: >- URI di reindirizzamento consentiti per i flussi in stile OAuth e di reindirizzamento della verifica. example: - https://acme.example/callback terms_url: type: string nullable: true description: URL dei termini di servizio mostrato nel flusso di verifica. example: https://acme.example/terms privacy_url: type: string nullable: true description: URL dell'informativa sulla privacy mostrato nel flusso di verifica. example: https://acme.example/privacy description: type: string nullable: true description: >- Descrizione interna dell'applicazione (non mostrata agli utenti finali). created_at: type: string format: date-time example: '2025-06-01T10:00:00Z' data_location: $ref: '#/components/schemas/ApplicationDataLocation' products: type: array readOnly: true description: >- I prodotti dell'applicazione. Sempre tutti e tre, in questo ordine: `identity`, `transactions`, `authentication`. Una nuova applicazione ha `identity` abilitato con tutti i moduli attivi, e `transactions` e `authentication` disabilitati. Di sola lettura: una chiave `products` nel corpo di creazione o aggiornamento viene ignorata. items: $ref: '#/components/schemas/ApplicationProduct' example: - product: identity status: enabled modules: user_verification: true business_verification: true case_management: true - product: transactions status: disabled modules: travel_rule: true case_management: true - product: authentication status: disabled modules: {} AuthError: type: object description: Contenitore di errori di autenticazione / autorizzazione / non trovato. properties: detail: type: string example: Invalid access token ApplicationDataLocation: type: string enum: - eu - au - mx description: >- Dove vengono archiviati ed elaborati i dati di verifica dell'applicazione; questa posizione viene scelta al momento della creazione dell'applicazione. `eu` indica l'Unione Europea (Irlanda), il valore predefinito. `au` (Australia, Sydney) e `mx` (Messico) saranno presto disponibili: una richiesta che li specifica risponde con 400 `This data location is not available yet.` L'applicazione Sandbox di un'organizzazione si trova sempre nell'Unione Europea. example: eu ApplicationProduct: type: object description: >- Un prodotto di un'applicazione e il suo stato. Di sola lettura: gli endpoint dell'applicazione lo restituiscono e lo ignorano nel corpo della richiesta. properties: product: type: string enum: - identity - transactions - authentication description: >- `identity` (Verifica dell'identità), `transactions` (Monitoraggio delle transazioni) o `authentication` (Autenticazione). example: identity status: type: string enum: - enabled - early_access - disabled description: >- Indica se il prodotto è attivo per questa applicazione. `early_access` si applica solo ad `authentication`, che Didit attiva per te. example: enabled modules: type: object additionalProperties: type: boolean description: >- Interruttori dei moduli del prodotto, ciascuno `true` o `false`. `identity` include `user_verification`, `business_verification` e `case_management`. `transactions` include `travel_rule` e `case_management`. `authentication` non ne include nessuno (`{}`). `case_management` è un'impostazione mostrata sia sotto `identity` sia sotto `transactions`, pertanto ha lo stesso valore in entrambe. example: user_verification: true business_verification: true case_management: true required: - product - status - modules securitySchemes: BearerAuth: type: http scheme: bearer bearerFormat: JWT description: >- `access_token` JWT firmato con RS256 restituito da `POST /programmatic/login/` o `POST /programmatic/verify-email/`. Invia come `Authorization: Bearer `. La durata predefinita è di 86400 secondi (24 ore). Questo token è valido solo per gli endpoint di Account Management su `apx.didit.me/auth/v2`. L'API di verifica (`verification.didit.me/v3`) utilizza invece la `api_key` a lunga durata come `x-api-key`. ```` This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.