> ## 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.

# Avvio rapido autenticazione: primo accesso in 10 minuti

> Attiva l'autenticazione Didit in un'applicazione sandbox, fai accedere un utente con la pagina ospitata e verifica il suo access token sul server.

Questa guida rapida ti permette di far funzionare Didit Authentication dall'inizio alla fine in circa 10 minuti.
Registri un URL di callback in un'applicazione sandbox, attivi un metodo di accesso, fai accedere una persona tramite la pagina di accesso ospitata, verifichi il suo token di accesso sul tuo server e controlli l'accesso nella console.

## Prerequisiti

* Un account Didit con un'applicazione Sandbox. La creazione di un account è gratuita e in ogni applicazione Sandbox l'Autenticazione è attiva.
* Node.js 20 o successivo e un'app web che puoi eseguire su `http://localhost:3000`.

## Passaggi

**1. Apri la tua applicazione sandbox**

Nella [Business Console](https://business.didit.me), usa il selettore delle applicazioni per selezionare la tua applicazione **Sandbox**, quindi apri **Authentication**.

Un'applicazione Sandbox accetta callback su `http://localhost` e le credenziali di test di Didit per l'accesso con i social, e non viene mai fatturata.
Un'applicazione Live attiva invece Authentication dalla pagina **Products**: vedi [preparare la tua applicazione](https://docs.didit.me/it/authentication/overview.md#prepara-la-tua-applicazione).

**2. Registra il tuo URL di callback e l'origine**

Apri **Authentication > Security and sessions > Redirect URLs and allowed origins** e aggiungi:

| Cosa | Valore |
| - | - |
| URL di reindirizzamento | `http://localhost:3000/auth/callback` |
| Origine consentita | `http://localhost:3000` |

Didit restituisce una persona solo a un URL di reindirizzamento che hai registrato, carattere per carattere.
L'origine consentita permette al browser di scambiare il codice con l'origine Didit della tua applicazione.

![La card Redirect URLs and allowed origins nella Didit Business Console, accanto ad allowlist e blocklist e all'URL di accesso](https://mintcdn.com/didit-0f962782/RpqZjIB1GnUPdMTN/images/authentication/console-redirect-urls.png?fit=max\&auto=format\&n=RpqZjIB1GnUPdMTN\&q=85\&s=8bf9cdacf97580097f4e8c6bd242af6f)

URL di reindirizzamento e origini consentite, in Authentication > Security and sessions.

**3. Attiva un metodo di accesso**

Apri **Authentication > Sign-in methods** e attiva **Email code**.
Una nuova applicazione parte con tutti i metodi disattivati, e la pagina ospitata mostra solo i metodi che attivi.

Aggiungi anche **Passkeys** se vuoi, oppure un metodo di accesso social usando le **credenziali di test di Didit**, che funzionano in Sandbox senza una tua app.
Ogni metodo è descritto in [metodi di accesso](https://docs.didit.me/it/authentication/sign-in-methods.md).

![La pagina Sign-in methods nella Didit Business Console, con la card della pagina di accesso ospitata, i metodi senza password e con password e un'anteprima in tempo reale della pagina ospitata](https://mintcdn.com/didit-0f962782/RpqZjIB1GnUPdMTN/images/authentication/console-sign-in-methods.png?fit=max\&auto=format\&n=RpqZjIB1GnUPdMTN\&q=85\&s=4f71ad0125f22dd8184ad837854ec8db)

Authentication > Sign-in methods, con un'anteprima in tempo reale della pagina ospitata.

**4. Copia la tua chiave pubblicabile**

Apri **Authentication > Developers** e copia la **Publishable key**.
In un'applicazione Sandbox inizia con `pk_test_`.

La chiave pubblicabile è pubblica e identifica l'origine di accesso Didit della tua applicazione.
Non inserire mai la **Secret key** nel codice del browser o delle app mobili.

**5. Installa l'SDK e accedi**

```bash theme={null}
npm install @didit-protocol/auth
```

```ts auth.ts theme={null}
import { createDiditAuth } from "@didit-protocol/auth";

export const auth = createDiditAuth({
  publishableKey: "pk_test_...",
  redirectUri: "http://localhost:3000/auth/callback",
});

// Your sign-in button
export async function onSignInClick() {
  await auth.signIn({ returnTo: "/dashboard" });
}

// Run once on http://localhost:3000/auth/callback
export async function onCallbackPage() {
  const { session, returnTo } = await auth.handleRedirectCallback();
  console.log(session.email, session.vendorData);
  window.location.replace(returnTo ?? "/");
}
```

Clicca sul tuo pulsante: la pagina ospitata chiede un indirizzo email e invia un codice di sei cifre.
Inserisci il codice, e Didit ti riporta al tuo callback, che scambia il codice monouso con i token della sessione.
Un primo accesso con un indirizzo che non ha ancora un account ne crea uno, perché il criterio di registrazione predefinito permette a chiunque di registrarsi.

![La pagina di accesso ospitata su un telefono, con un pulsante passkey e campi per email e password](https://mintcdn.com/didit-0f962782/RpqZjIB1GnUPdMTN/images/authentication/hosted-sign-in-phone.png?fit=max\&auto=format\&n=RpqZjIB1GnUPdMTN\&q=85\&s=842077ff63a6dcffc50b0f0542ab07e4)

La pagina di accesso ospitata su un telefono. Mostra solo i metodi che hai attivato.

**6. Verifica il token sul tuo server**

Invia il token di accesso da `auth.getToken()` al tuo backend nell'intestazione `Authorization`, e verificalo lì a ogni richiesta protetta:

```ts server.ts theme={null}
import { verifyToken } from "@didit-protocol/auth/server";

export async function authenticate(request: Request) {
  const header = request.headers.get("authorization") ?? "";
  const token = header.startsWith("Bearer ") ? header.slice(7) : "";
  try {
    const claims = await verifyToken(token, { publishableKey: process.env.DIDIT_PUBLISHABLE_KEY });
    return { personId: claims.sub, vendorData: claims.vendor_data };
  } catch {
    return null;
  }
}
```

`verifyToken` verifica la firma ES256 rispetto alle chiavi pubblicate dal tuo emittente e controlla l'emittente e la scadenza.
I token di accesso durano al massimo 5 minuti, e `auth.getToken()` li rinnova per te.
Gli altri linguaggi verificano lo stesso token con gli [SDK lato server](https://docs.didit.me/it/integration/server-sdks/overview.md) o con una qualsiasi libreria JWT, come mostra [token e JWKS](https://docs.didit.me/it/authentication/tokens-and-jwks.md#verifica-un-token-sul-tuo-server).

**7. Vedi l'accesso nella console**

Apri **Authentication > Sign-ins**.
Il tuo accesso è elencato con il suo esito, metodo, dispositivo, posizione e rischio, accanto agli accessi di esempio con cui ogni sandbox inizia.
La persona compare sotto **Users**.

![La pagina Sign-ins nella Didit Business Console, che elenca i tentativi di accesso con stato, persona, metodo, dispositivo, posizione, rischio e orario](https://mintcdn.com/didit-0f962782/RpqZjIB1GnUPdMTN/images/authentication/console-sign-ins.png?fit=max\&auto=format\&n=RpqZjIB1GnUPdMTN\&q=85\&s=3c79b4e120c911b732d738e52d1687c8)

Authentication > Sign-ins: ogni tentativo, con filtri per stato, metodo e rischio.

Per ricevere l'attività di accesso sul tuo server, associa una [destinazione webhook](https://docs.didit.me/it/integration/webhooks.md) agli eventi `auth.signup` e `auth.login`. Vedi [eventi e webhook](https://docs.didit.me/it/authentication/events-and-webhooks.md).

## Prima di andare in produzione

1. Attiva l'autenticazione per la tua applicazione Live nella pagina **Products**.
2. Registra in quella stessa pagina i tuoi URL di reindirizzamento e le origini di produzione `https://`: un'applicazione Live accetta solo `https://`.
3. Sostituisci le credenziali di test di Didit per l'accesso tramite social con l'ID client e il segreto della tua app.
4. Copia la chiave pubblicabile Live (`pk_live_`) nella configurazione di produzione.
5. Segui la [checklist per la messa in produzione](https://docs.didit.me/it/authentication/integration-guide.md#checklist-per-il-go-live).

## Prossimi passi

> [card] [Guida all'integrazione](https://docs.didit.me/it/authentication/integration-guide.md)
>
> Schermate ospitate o proprie, archiviazione dei token, sessioni, step-up e risoluzione dei problemi.

> [card] [React e Next.js](https://docs.didit.me/it/authentication/quickstarts/nextjs.md)
>
> Componenti, hook, cookie HttpOnly e `auth()` lato server.

> [card] [iOS, Android, React Native e Flutter](https://docs.didit.me/it/authentication/quickstarts/ios.md)
>
> Accesso nativo con il browser di sistema, passkey e archiviazione protetta.

> [card] [Protezione dai bot](https://docs.didit.me/it/authentication/bot-protection.md)
>
> Attiva le policy che bloccano i bot e la presa di controllo degli account.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.