Stripe Identity

https://docs.stripe.com/identity
Admin
Stripe Identity allows businesses to verify government-issued IDs, match documents to selfies, and...
Tokens:12,988
Snippets:150
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Stripe Ruby gem

Source: https://docs.stripe.com/identity/handle-verification-outcomes

Install the Stripe Ruby gem directly using gem install or declare it in your Bundler Gemfile.

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

--------------------------------

### Example VerificationReport JSON

Source: https://docs.stripe.com/identity/verification-checks?type=selfie

A sample response object showing successful document and selfie verification status.

```JSON
{
  "id": "vr_",
  "object": "identity.verification_report",
  "type": "document",
  "verification_session": "vs_",
  "created": 1611776872,
  "livemode": true,
  "options": {
    "document": {
      "require_matching_selfie": true
    }
  },
  "document": {
    "status": "verified",
    "error": null,
    "first_name": "Jenny",
    "last_name": "Rosen",
    "address": {
      "line1": "1234 Main St.",
      "city": "San Francisco",
      "state": "CA",
      "postal_code": "94111",
      "country": "US"
    },
    "document_type": "id_card",
    "expiration_date": {
      "day": 17,
      "month": 7,
      "year": 2024
    },
    "files": ["file_", "file_"],
    "issued_date": {
      "day": 4,
      "month": 27,
      "year": 2021
    },
    "issuing_country": "US"
  },
  "selfie": {
    "status": "verified",
    "error": null,
    "document": "file_",
    "selfie": "file_",
  }
}
```

--------------------------------

### GET /v1/identity/verification_sessions/:id

Source: https://docs.stripe.com/identity/verification-checks?type=selfie

Retrieves a VerificationSession and expands the last_verification_report to access selfie check results.

```APIDOC
## GET /v1/identity/verification_sessions/:id

### Description
Retrieves the details of a specific VerificationSession. By expanding the last_verification_report field, you can access the results of the document and selfie checks.

### Method
GET

### Endpoint
https://api.stripe.com/v1/identity/verification_sessions/:id

### Parameters
#### Path Parameters
- **id** (string) - Required - The ID of the VerificationSession to retrieve.

#### Query Parameters
- **expand[]** (array) - Optional - Set to ['last_verification_report'] to include the report in the response.

### Response
#### Success Response (200)
- **last_verification_report** (object) - The VerificationReport containing document and selfie verification status.
```

--------------------------------

### Initialize Stripe.js

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

Initialize Stripe.js with your publishable API key within a script tag.

```html
<html>
  <head>
    <title>Verify your identity</title>
    <script src="https://js.stripe.com/dahlia/stripe.js"></script>
  </head>
  <body>
    <button id="verify-button">Verify</button>
    <script type="text/javascript">
      // Set your publishable key: remember to change this to your live publishable key in production
      // See your keys here: https://dashboard.stripe.com/apikeys
      var stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx');
    </script>
  </body>
</html>
```

--------------------------------

### Add Verification Button and Stripe.js

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

Create a button element and include the required Stripe.js script tag in your HTML.

```html
<html>
  <head>
    <title>Verify your identity</title>
  </head>
  <body>
    <button id="verify-button">Verify</button>
  </body>
</html>
```

```html
<html>
  <head>
    <title>Verify your identity</title>
    <script src="https://js.stripe.com/dahlia/stripe.js"></script>
  </head>
  <body>
    <button id="verify-button">Verify</button>
  </body>
</html>
```

--------------------------------

### Create a webhook endpoint using cURL

Source: https://docs.stripe.com/identity/handle-verification-outcomes

Programmatically registers a webhook endpoint to listen for specific Identity Verification Session events. Replace the placeholder secret key and domain with your actual values.

```bash
curl https://api.stripe.com/v1/webhook_endpoints \
  -u <<YOUR_SECRET_KEY>>: \
  -d "url"="https://{{DOMAIN}}/my/webhook/endpoint" \
  -d "enabled_events[]"="identity.verification_session.verified" \
  -d "enabled_events[]"="identity.verification_session.requires_input"
```

--------------------------------

### Create a VerificationSession endpoint in Node.js

Source: https://docs.stripe.com/identity/verification-sessions

Create a verification session on the server and return only the client secret to the frontend. Ensure user authentication is handled before creating the session.

```javascript

// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

// In the route handler for /create-verification-session:
// Authenticate your user.

// Create the session.
const verificationSession = await stripe.identity.verificationSessions.create({
  type: 'document',
  provided_details: {
    email: 'user@example.com',
  },
  metadata: {
    user_id: '{{USER_ID}}',
  },
});

// Return only the client secret to the frontend.
const clientSecret = verificationSession.client_secret;
```

--------------------------------

### Create a confirmation page

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

A minimal HTML page to display after a user successfully submits their identity document.

```html
<html>
  <head><title>Your document was submitted</title></head>
  <body>
    <h1>Thanks for submitting your identity document.</h1>
    <p>
      We are processing your verification.
    </p>
  </body>
</html>
```

--------------------------------

### Implement verification button handler

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

Client-side implementation to trigger the Stripe verification modal and redirect to a confirmation page upon success.

```html
<html>
  <head>
    <title>Verify your identity</title>
    <script src="https://js.stripe.com/dahlia/stripe.js"></script>
  </head>
  <body>
    <button id="verify-button">Verify</button>

    <script type="text/javascript">
      // Set your publishable key: remember to change this to your live publishable key in production
      // See your keys here: https://dashboard.stripe.com/apikeys
      var stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx')

      var verifyButton = document.getElementById('verify-button');

      verifyButton.addEventListener('click', function() {
        // Get the VerificationSession client secret using the server-side
        // endpoint you created in step 3.
        fetch('/create-verification-session', {
          method: 'POST',
        })
        .then(function(response) {
          return response.json();
        })
        .then(function(session) {
          // Show the verification modal.
          return stripe.verifyIdentity(session.client_secret);
        })
        .then(function(result) {
          // If `verifyIdentity` fails, you should display the error message
          // using `error.message`.
          if (result.error) {
            alert(result.error.message);
          } else {
            window.location.href = 'submitted.html';
          }
        })
        .catch(function(error) {
          console.error('Error:', error);
        });
      });
    </script>
  </body>
</html>
```

--------------------------------

### Create Verification Session with User Details (curl)

Source: https://docs.stripe.com/identity/verification-flows

Attach user-specific data like phone, email, and a client reference ID when creating a verification session via the API.

```curl
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "verification_flow={{IDENTITYVERIFICATIONFLOW_ID}}" \
  -d "provided_details[phone]=5555551212" \
  --data-urlencode "provided_details[email]=user@domain.com" \
  -d client_reference_id=reference-token
```

--------------------------------

### Create a VerificationSession with cURL

Source: https://docs.stripe.com/identity/verification-sessions

Creates a new VerificationSession configured for document verification checks. Replace <<YOUR_SECRET_KEY>> with your actual Stripe secret API key.

```curl
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d type=document
```

--------------------------------

### POST /v1/identity/verification_sessions

Source: https://docs.stripe.com/identity/verification-checks?type=selfie

Creates a new VerificationSession with selfie verification enabled.

```APIDOC
## POST /v1/identity/verification_sessions

### Description
Creates a new VerificationSession and configures the verification flow to require a government-issued photo ID and a selfie from the user.

### Method
POST

### Endpoint
https://api.stripe.com/v1/identity/verification_sessions

### Request Body
- **type** (string) - Required - The type of verification, set to 'document'.
- **options[document][require_matching_selfie]** (boolean) - Required - Set to true to enable selfie checks.

### Request Example
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d type=document \
  -d "options[document][require_matching_selfie]=true"
```

--------------------------------

### Test VerificationSession Endpoint

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

Use curl to verify your server-side endpoint is correctly returning the VerificationSession details.

```bash
curl -X POST -is "http://localhost:4242/create-verification-session" -d ""
```

```json
HTTP/1.1 200 OK
Content-Type: application/json

{ id: "vs_QdfQQ6xfGNJR7ogV6", client_secret: "vs_QdfQQ6xfGNJR7ogV6_secret_live_..."  }
```

--------------------------------

### Create a VerificationSession with selfie check

Source: https://docs.stripe.com/identity/verification-checks?type=selfie

Use the options.document.require_matching_selfie parameter to mandate a selfie check during the verification process.

```cURL
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "sk_test_BQokikJOvBiI2HlWgH4olfQ2:" \
  -d type=document \
  -d "options[document][require_matching_selfie]=true"
```

--------------------------------

### Retrieve verified outputs in Node.js

Source: https://docs.stripe.com/identity/access-verification-results

Expand the verified_outputs field when retrieving a VerificationSession using your secret key to access basic verified PII without needing a restricted key.

```javascript

// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

const verificationSession = await stripe.identity.verificationSessions.retrieve(
  '{{SESSION_ID}}',
  {
    expand: [
      'verified_outputs',
    ],
  }
);

const firstName = verificationSession.verified_outputs.first_name;
```

--------------------------------

### Inspect failed VerificationSession object with error details in JSON

Source: https://docs.stripe.com/identity/verification-sessions

Use last_error.code to programmatically handle verification failure types and last_error.reason to display error details to the user.

```json
{
  "id": "vs_orWziM4j7CiRL8J4vQmXgW2w",
  "object": "identity.verification_session",
  "created": 1610744321,
  "last_error": {
    "code": "document_expired",
    "reason": "The document is expired.",
  },
  "last_verification_report": "vr_orWziM4j7CiRL8J4vQmXgW2w",
  "livemode": true,
  "metadata": {},
  "options": {},
  "status": "requires_input",
  "type": "document",
  "redaction": null,
  "url": null,
}
```

--------------------------------

### Inspect verified VerificationSession object in JSON

Source: https://docs.stripe.com/identity/verification-sessions

Expand the verified_outputs field on a session with a 'verified' status to access extracted user and document data.

```json
{
  "id": "vs_orWziM4j7CiRL8J4vQmXgW2w",
  "object": "identity.verification_session",
  "created": 1610744321,
  "last_error": null,
  "last_verification_report": "vr_orWziM4j7CiRL8J4vQmXgW2w",
  "livemode": true,
  "metadata": {},
  "options": {
    "document": {},
  },
  "status": "verified",
  "type": "document",
  "redaction": null,
  "url": null,
  "verified_outputs": {
    "first_name": "Jenny",
    "last_name": "Rosen",
    "address": {
      "line1": "1234 Main St.",
      "city": "San Francisco",
      "state": "CA",
      "postal_code": "94111",
      "country": "US"
    },
    "id_number_type": null
  }
}
```

--------------------------------

### Create VerificationSession with metadata in cURL

Source: https://docs.stripe.com/identity/verification-sessions

Attach custom key-value pairs to correlate Stripe verification sessions with internal user accounts. Avoid storing sensitive PII in metadata, as it is removed upon session redaction.

```curl
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d type=document \
  -d "metadata[user_id]={{USER_ID}}" \
  -d "metadata[reference]={{IDENTIFIER}}"
```

--------------------------------

### Create short-lived FileLink for Identity images in Node.js

Source: https://docs.stripe.com/identity/access-verification-results

Requires authenticating with a restricted key and expanding last_verification_report when retrieving the verification session. FileLinks generated for identity document and selfie files must be set to expire within 30 seconds.

```javascript

// Set your restricted key. Remember to switch to a live restricted key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('rk_test_...');

// Get the VerificationReport
const session = await stripe.identity.verificationSessions.retrieve(
  '{{SESSION_ID}}',
  {
    expand: ['last_verification_report'],
  }
);

// Retrieve the File id
const report = session.last_verification_report;
const documentFrontFile = report.document.files[0];

// Create a short-lived FileLink
const fileLink = await stripe.fileLinks.create({
  file: documentFrontFile,
  expires_at: Math.floor(Date.now() / 1000) + 30,  // link expires in 30 seconds
});

// Access the FileLink URL to download file contents
const fileUrl = fileLink.url;
```

--------------------------------

### POST /v1/identity/verification_sessions

Source: https://docs.stripe.com/identity/verification-flows

Creates a new identity verification session using a pre-configured verification flow. You can attach user-specific details such as phone number, email, and a client reference ID to the session.

```APIDOC
## POST /v1/identity/verification_sessions

### Description
Creates a new identity verification session using a pre-configured verification flow. You can attach user-specific details such as phone number, email, and a client reference ID to the session for better tracking and pre-filling.

### Method
POST

### Endpoint
/v1/identity/verification_sessions

### Parameters
#### Request Body
- **verification_flow** (string) - Required - The ID of the verification flow to use for this session.
- **provided_details[phone]** (string) - Optional - A user-specific phone number to attach to the verification session.
- **provided_details[email]** (string) - Optional - A user-specific email address to attach to the verification session.
- **client_reference_id** (string) - Optional - A reference to a user in your system that you can look up later.

### Request Example
```json
{
  "verification_flow": "{{IDENTITYVERIFICATIONFLOW_ID}}",
  "provided_details": {
    "phone": "5555551212",
    "email": "user@domain.com"
  },
  "client_reference_id": "reference-token"
}
```
```

--------------------------------

### Create a webhook endpoint in Node.js

Source: https://docs.stripe.com/identity/handle-verification-outcomes

Requires raw request body parsing to verify the Stripe signature header against your endpoint secret. Ensure your webhook route bypasses standard JSON body parsing.

```javascript

// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

// You can find your endpoint's secret in your webhook settings
const endpointSecret = 'whsec_...';

// This example uses Express to receive webhooks
const express = require('express');

// Use body-parser to retrieve the raw body as a buffer
const bodyParser = require('body-parser');

const app = express();

// Use JSON parser for all non-webhook routes
app.use((req, res, next) => {
  if (req.originalUrl === '/webhook') {
    next();
  } else {
    bodyParser.json()(req, res, next);
  }
});

app.post('/webhook', bodyParser.raw({type: 'application/json'}), (req, res) => {
  let event;

  // Verify the event came from Stripe
  try {
    const sig = req.headers['stripe-signature'];
    event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
  } catch (err) {
    // On error, log and return the error message
    console.log(`❌ Error message: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  // Successfully constructed event

  res.json({received: true});
});

app.listen(4242, () => {
  console.log('Running on port 4242');
});
```

--------------------------------

### Add Identity Verification Button

Source: https://docs.stripe.com/identity/verify-identity-documents?platform=web&type=modal

Implement the client-side logic to fetch the client secret and trigger the Stripe identity verification modal.

```html
<html>
  <head>
    <title>Verify your identity</title>
    <script src="https://js.stripe.com/dahlia/stripe.js"></script>
  </head>
  <body>
    <button id="verify-button">Verify</button>

    <script type="text/javascript">
      // Set your publishable key: remember to change this to your live publishable key in production
      // See your keys here: https://dashboard.stripe.com/apikeys
      var stripe = Stripe('pk_test_TYooMQauvdEDq54NiTphI7jx');

      var verifyButton = document.getElementById('verify-button');

      verifyButton.addEventListener('click', function() {
        // Get the VerificationSession client secret using the server-side
        // endpoint you created in step 3.
        fetch('/create-verification-session', {
          method: 'POST',
        })
        .then(function(response) {
          return response.json();
        })
        .then(function(session) {
          // Show the verification modal.
          return stripe.verifyIdentity(session.client_secret);
        })
        .then(function(result) {
          // If `verifyIdentity` fails, you should display the localized
          // error message to your user using `error.message`.
          if (result.error) {
            alert(result.error.message);
          }
        })
        .catch(function(error) {
          console.error('Error:', error);
        });
      });
    </script>
  </body>
</html>
```

--------------------------------

### Redacted VerificationSession JSON Response

Source: https://docs.stripe.com/identity/verification-sessions

Demonstrates the response format when retrieving a redacted VerificationSession with expanded PII fields, showing placeholder values instead of personal data.

```json

{
  "id": "vs_orWziM4j7CiRL8J4vQmXgW2w",
  "object": "identity.verification_session",
  "created": 1610744321,
  "last_error": null,
  "last_verification_report": "vr_orWziM4j7CiRL8J4vQmXgW2w",
  "livemode": true,
  "options": {},
  "status": "verified",
  "type": "document",
  "url": null,
  "client_secret": null,
  "redaction": {
    "status": "redacted"
  },
  "verified_outputs": {
    "first_name": "[redacted]",
    "last_name": "[redacted]",
    "dob": {
      "year": 1,
      "month": 1,
      "day": 1
    },
    "address": {
      "line1": "[redacted]",
      "city": "[redacted]",
      "state": "[redacted]",
      "postal_code": "[redacted]",
      "country": "US"
    },
    "id_number_type": null
  },
  "metadata": {} // Metadata will also be redacted
}
```

--------------------------------

### Handle identity verification webhooks in Node.js

Source: https://docs.stripe.com/identity/handle-verification-outcomes

Requires raw body parsing on the webhook endpoint to verify the Stripe signature. Listens for the identity.verification_session.verified event when verification checks pass.

```javascript

// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

// You can find your endpoint's secret in your webhook settings
const endpointSecret = 'whsec_...';

// This example uses Express to receive webhooks
const express = require('express');

// Use body-parser to retrieve the raw body as a buffer
const bodyParser = require('body-parser');

const app = express();

// Use JSON parser for all non-webhook routes
app.use((req, res, next) => {
  if (req.originalUrl === '/webhook') {
    next();
  } else {
    bodyParser.json()(req, res, next);
  }
});

app.post('/webhook', bodyParser.raw({type: 'application/json'}), (req, res) => {
  let event;

  // Verify the event came from Stripe
  try {
    const sig = req.headers['stripe-signature'];
    event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
  } catch (err) {
    // On error, log and return the error message
    console.log(`❌ Error message: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  // Successfully constructed event
  switch (event.type) {
    case 'identity.verification_session.verified': {
      // All the verification checks passed
      const verificationSession = event.data.object;
      break;
    }
  }

  res.json({received: true});
});

app.listen(4242, () => {
  console.log('Running on port 4242');
});
```

--------------------------------

### Create Verification Session with Flow ID (curl)

Source: https://docs.stripe.com/identity/verification-flows

Use this snippet to initiate an identity verification session by passing a specific verification flow ID to the Stripe API.

```curl
curl https://api.stripe.com/v1/identity/verification_sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "verification_flow={{IDENTITYVERIFICATIONFLOW_ID}}"
```

--------------------------------

### Retrieve VerificationReport for selfie results

Source: https://docs.stripe.com/identity/verification-checks?type=selfie

Expand the last_verification_report field when retrieving a session to access the document and selfie check results.

```Node.js
// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('sk_test_BQokikJOvBiI2HlWgH4olfQ2');
const verificationSession = await stripe.identity.verificationSessions.
retrieve
(
  '{{SESSION_ID}}',
  {
    
expand
: ['last_verification_report'],
  }
);
const verificationReport = verificationSession.last_verification_report;
```

--------------------------------

### Retrieve sensitive verification results in Node.js

Source: https://docs.stripe.com/identity/access-verification-results

Requires authentication using a restricted API key with sensitive verification permissions. Expand specific fields on verified_outputs and last_verification_report to obtain protected document details.

```javascript

// Set your restricted key. Remember to switch to a live restricted key in production.
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = require('stripe')('rk_test_...');

const verificationSession = await stripe.identity.verificationSessions.retrieve(
  '{{SESSION_ID}}',
  {
    expand: [
      'verified_outputs.dob',
      'verified_outputs.id_number',
      'last_verification_report.document.number',
      'last_verification_report.document.expiration_date',
    ],
  }
);

const dateOfBirth = verificationSession.verified_outputs.dob;
const idNumber = verificationSession.verified_outputs.id_number;
const documentNumber = verificationSession.last_verification_report.document.number;
const documentExpirationDate = verificationSession.last_verification_report.document.expiration_date;
```

--------------------------------

### Handle verification session webhooks in Node.js

Source: https://docs.stripe.com/identity/handle-verification-outcomes

Receives and verifies Stripe Identity webhook events to handle successful verifications and check failures using Express. Requires the raw request body to construct and validate the webhook signature.

```javascript

// Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
// Find your keys at https://dashboard.stripe.com/apikeys.
const stripe = require('stripe')('<<YOUR_SECRET_KEY>>');

// You can find your endpoint's secret in your webhook settings
const endpointSecret = 'whsec_...';

// This example uses Express to receive webhooks
const express = require('express');

// Use body-parser to retrieve the raw body as a buffer
const bodyParser = require('body-parser');

const app = express();

// Use JSON parser for all non-webhook routes
app.use((req, res, next) => {
  if (req.originalUrl === '/webhook') {
    next();
  } else {
    bodyParser.json()(req, res, next);
  }
});

app.post('/webhook', bodyParser.raw({type: 'application/json'}), (req, res) => {
  let event;

  // Verify the event came from Stripe
  try {
    const sig = req.headers['stripe-signature'];
    event = stripe.webhooks.constructEvent(req.body, sig, endpointSecret);
  } catch (err) {
    // On error, log and return the error message
    console.log(`❌ Error message: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  // Successfully constructed event
  switch (event.type) {
    case 'identity.verification_session.verified': {
      // All the verification checks passed
      const verificationSession = event.data.object;
      break;
    }
    case 'identity.verification_session.requires_input': {
      // At least one of the verification checks failed
      const verificationSession = event.data.object;

      console.log('Verification check failed: ' + verificationSession.last_error.reason);

      // Handle specific failure reasons
      switch (verificationSession.last_error.code) {
        case 'document_unverified_other': {
          // The document was invalid
          break;
        }
        case 'document_expired': {
          // The document was expired
          break;
        }
        case 'document_type_not_supported': {
          // document type not supported
          break;
        }
        default: {
          // ...
        }
      }
    }
  }

  res.json({received: true});
});

app.listen(4242, () => {
  console.log('Running on port 4242');
});
```

--------------------------------

### Redact a VerificationSession with cURL

Source: https://docs.stripe.com/identity/verification-sessions

Initiates permanent redaction of personal data from a VerificationSession. If the session is currently processing, you must wait until processing finishes before redacting.

```curl
curl -X POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/redact \
  -u "<<YOUR_SECRET_KEY>>:"
```

--------------------------------

### Fetch the VerificationSession client secret in JavaScript

Source: https://docs.stripe.com/identity/verification-sessions

Fetch the client secret from the server endpoint within a frontend client application before calling stripe.verifyIdentity(). The page must use TLS to protect the sensitive client secret.

```javascript
(async () => {
  const response = await fetch('/create-verification-session');
  const {client_secret: clientSecret} = await response.json();
  // Call stripe.verifyIdentity() with the client secret.
})();
```

--------------------------------

### POST /v1/identity/verification_sessions/{IDENTITYVERIFICATIONSESSION_ID}/redact

Source: https://docs.stripe.com/identity/verification-sessions

Redacts a VerificationSession to delete personal information. Redacted sessions replace personally identifiable information (PII) with placeholder values and cannot be updated.

```APIDOC
## POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/redact

### Description
Redact a VerificationSession to ensure Stripe deletes personal information. After personal information is deleted, PII fields contain placeholder values. Redacting a session with `requires_action` status automatically cancels it. Redaction cannot be performed while a session is in the `processing` state.

### Method
POST

### Endpoint
`https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/redact`

### Parameters
#### Path Parameters
- **IDENTITYVERIFICATIONSESSION_ID** (string) - Required - The identifier of the VerificationSession to redact.

### Request Example
```bash
curl -X POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/redact \
  -u "<<YOUR_SECRET_KEY>>:"
```

### Response Example
```json
{
  "id": "vs_orWziM4j7CiRL8J4vQmXgW2w",
  "object": "identity.verification_session",
  "created": 1610744321,
  "last_error": null,
  "last_verification_report": "vr_orWziM4j7CiRL8J4vQmXgW2w",
  "livemode": true,
  "options": {},
  "status": "verified",
  "type": "document",
  "url": null,
  "client_secret": null,
  "redaction": {
    "status": "redacted"
  },
  "verified_outputs": {
    "first_name": "[redacted]",
    "last_name": "[redacted]",
    "dob": {
      "year": 1,
      "month": 1,
      "day": 1
    },
    "address": {
      "line1": "[redacted]",
      "city": "[redacted]",
      "state": "[redacted]",
      "postal_code": "[redacted]",
      "country": "US"
    },
    "id_number_type": null
  },
  "metadata": {}
}
```
```

--------------------------------

### Cancel a VerificationSession with cURL

Source: https://docs.stripe.com/identity/verification-sessions

Cancels a VerificationSession before it enters processing or verified status. This action cannot be undone and invalidates future submission attempts.

```curl
curl -X POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/cancel \
  -u "<<YOUR_SECRET_KEY>>:"
```

--------------------------------

### POST /v1/identity/verification_sessions/{IDENTITYVERIFICATIONSESSION_ID}/cancel

Source: https://docs.stripe.com/identity/verification-sessions

Cancels a VerificationSession at any point before it is processing or verified. This invalidates the VerificationSession for future submission attempts and sets its status to canceled.

```APIDOC
## POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/cancel

### Description
Cancel a VerificationSession at any point before it is `processing` or `verified`. This invalidates the VerificationSession for future submission attempts, cannot be undone, and sets the session status to `canceled`.

### Method
POST

### Endpoint
`https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/cancel`

### Parameters
#### Path Parameters
- **IDENTITYVERIFICATIONSESSION_ID** (string) - Required - The identifier of the VerificationSession to cancel.

### Request Example
```bash
curl -X POST https://api.stripe.com/v1/identity/verification_sessions/{{IDENTITYVERIFICATIONSESSION_ID}}/cancel \
  -u "<<YOUR_SECRET_KEY>>:"
```
```
Tokens:
Raw