Evervault

https://docs.evervault.com
Admin
Evervault is a security infrastructure platform providing tools for handling sensitive data, secure...
Tokens:338,003
Snippets:2,309
Trust Score:9.7
Update:16 hours ago
Show doc for...
Tokens:
Raw
### Install the Evervault Go SDK

Source: https://docs.evervault.com/sdks/go

Use `go get` to install the Evervault Go SDK package.

```bash
go get github.com/evervault/evervault-go
```

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

### Complete Node.js Dockerfile example

Source: https://docs.evervault.com/enclaves

A complete Dockerfile example for a Node.js application, including base image, copying files, exposing port 8008, installing dependencies, and setting the entrypoint.

```dockerfile
FROM node:24-alpine3.23

COPY ./index.js /index.js
COPY ./package.json /package.json
COPY ./package-lock.json /package-lock.json

EXPOSE 8008

RUN npm i

ENTRYPOINT ["node", "/index.js"]
```

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

### Install the Evervault Python SDK with pip

Source: https://docs.evervault.com/sdks/python

Install the SDK from PyPI using pip.

```bash
pip install evervault
```

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

### Install the Evervault Node.js SDK with npm

Source: https://docs.evervault.com/sdks/node

Install the @evervault/sdk package using npm. This is the first step to using the SDK.

```bash
npm install @evervault/sdk
```

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

### Install Evervault PHP SDK via Composer

Source: https://docs.evervault.com/sdks/php

Run this command to install the Evervault PHP bindings using Composer.

```bash
1$ composer require evervault/evervault-php
```

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

### Install Evervault CLI

Source: https://docs.evervault.com/sdks/cli

Run this command to install the Evervault CLI. It can also be used to upgrade from a previous major version.

```bash
1sh <(curl https://cli.evervault.com/v4/install -sL)
```

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

### Install Evervault CLI

Source: https://docs.evervault.com/enclaves

Install the Evervault CLI using the provided curl command. Requires Docker to be installed for building Enclaves.

```bash
curl https://cli.evervault.com/v4/install -sL | sh
```

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

### Example output from Evervault Function run()

Source: https://docs.evervault.com/sdks/php

Example JSON response from a successful run() invocation, showing the run ID, status, and result.

```json
1{
2  "id": "func_run_09413338da56",
3  "status": "success",
4  "result": {
5    "message": "Hello from a Function! It seems you have 14 letters in your name",
6    "name": "ev:RFVC:TTLHY04oVJlBuvPx:A7MeNriTKFES0Djl9uKaPvHCAn9PjSfOHu7tswXFCHF9:jwYKE13o3iQlr6Dn/DRk80XpNOGb:$"
7  }
8}
```

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

### Install @evervault/react with npm

Source: https://docs.evervault.com/sdks/react

Install the Evervault React SDK via npm. Use your preferred package manager (npm, yarn, pnpm) as shown in the tabs.

```bash
npm install @evervault/react
```

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

### Install Evervault React Native SDK via npm or yarn

Source: https://docs.evervault.com/sdks/react-native-legacy

Install the legacy React Native SDK using npm or yarn. The package name is @evervault/evervault-react-native for npm and @evervault/evervault-react-native for yarn.

```bash
## Using npm
npm install @evervault/evervault-react-native

## Using yarn
yarn add @evervault/evervault-react-native
```

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

### Initialize the Evervault Go SDK

Source: https://docs.evervault.com/sdks/go

Import the SDK and create a client using your App ID and API key. Replace `<APP_ID>` and `<API_KEY>` with your actual credentials.

```go
import "github.com/evervault/evervault-go"

evClient, err := evervault.MakeClient("<APP_ID>", "<API_KEY>")
```

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

### Evervault.shared.config(teamId:appId:)

Source: https://docs.evervault.com/sdks/ios

Configures a shared instance of the Evervault class with the provided team and app IDs. This is the simplest way to get started if you only need a single Evervault team/app.

```APIDOC
## Evervault.shared.config(teamId:appId:)

### Description
Configures the shared Evervault instance with the provided team and app IDs. This is the simplest way to get up and running if you only need to use a single Evervault team/app.

### Method
`Evervault.shared.config(teamId:appId:)`

### Parameters
- **teamId** (String) - Required - The UUID of your Evervault Team
- **appId** (String) - Required - The UUID of your Evervault App

### Request Example
```swift
import EvervaultCore

Evervault.shared.configure(teamId: "<TEAM_ID>", appId: "<APP_ID>")
```
```

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

### Create a starter function.toml

Source: https://docs.evervault.com/sdks/cli

Creates a starter function.toml file in the current directory.

```bash
1ev function create-toml
```

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

### Python Dockerfile with virtual environment

Source: https://docs.evervault.com/enclaves

Example Dockerfile for Python that uses a virtual environment to install dependencies, helping minimize image size. It copies requirements.txt and app.py, exposes port 8008, and sets the entrypoint.

```dockerfile
FROM python:3.13-slim

RUN python3 -m venv /opt/venv
COPY requirements.txt requirements.txt
RUN /opt/venv/bin/pip install -r requirements.txt

COPY app.py /app.py

EXPOSE 8008

ENTRYPOINT ["/opt/venv/bin/python", "/app.py"]
```

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

### Encrypt data with useEvervault hook

Source: https://docs.evervault.com/sdks/react

Use the useEvervault hook inside a child component to get an initialized instance of the JavaScript SDK, then call the encrypt() function to encrypt plaintext data. The example shows a form that encrypts a message and alerts the result.

```jsx
import { useState } from "react";
import { useEvervault } from "@evervault/react";

export default function ChildComponent() {
  const evervault = useEvervault();
  const [message, setMessage] = useState("");

  const handleSubmit = async (e) => {
    e.preventDefault();
    const encryptedMessage = await evervault.encrypt(message);
    alert(encryptedMessage);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input value={message} onChange={(e) => setMessage(e.target.value)} />
      <button>Submit</button>
    </form>
  );
}
```

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

### Initialize a sample Function

Source: https://docs.evervault.com/sdks/cli

Initializes a sample 'hello world' Function in the current directory or the directory provided by the --dir flag. If --dir is not given, the Function is created in a subdirectory of the current directory using the Function's name. Use --force to overwrite an existing directory.

```bash
1ev function init
```

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

### Example JSON endpoint returning encrypted card data

Source: https://docs.evervault.com/cards/reveal

Shows a sample response from a GET request to /cards/:id that returns encrypted card data. The endpoint must return encrypted data, not plaintext, and must set CORS headers to allow access from the Reveal iframe.

```json
{
  "card": {
      "number": "ev:debug:Tk9D:number:mqrANWE1KMapRVCX:A8Gse2iNxLKy8WLnBDkqtkt+TTSaJFNyc+R/toYd2d8n:FUM5vwjOIrHI+3Jk7QnVCUpHVS0aZQC80ih/wpHtR2o=:$",
      "cvv": "ev:debug:Tk9D:number:YG1KlyImadEc/qJz:A7odbz+iMRub/WHEO9bwLI5tig+nJ12aKCfWHtMU87rJ:/g1rhC8GeaGyWbM1Y0kaT45IKw==:$",
      "expiry": "09/28"
    }
  }
}
```

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

### 1ev function init

Source: https://docs.evervault.com/sdks/cli

Initializes a sample 'hello world' Function in the current directory or a specified directory.

```APIDOC
## 1ev function init

### Description
Initialize a sample "hello world" Function either in your current directory, or the directory provided.

### Command
```bash
1ev function init
```

### Flags
- **--dir** - The directory to initialize the Function into. If not given, the Function will be created in a subdirectory of the current directory using the name of the Function.
- **--force** - Overwrite the existing directory at the location if it exists.
```

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

### Using ThreeDSecure and ThreeDSecure.Frame in a custom checkout

Source: https://docs.evervault.com/sdks/react-native

This example shows how to integrate the ThreeDSecure component with the useThreeDSecure hook. It creates a 3DS session on your backend, starts the authentication with tds.start(), and displays the ThreeDSecure.Frame inside a modal. The modal's onRequestClose calls tds.cancel() to properly close the webview if the user closes it before completion.

```tsx
1import { ThreeDSecure, useThreeDSecure } from "@evervault/react-native";
2import { createThreeDSSession } from "@your/api";
3import { Button, Form, Modal } from "@your/ui";
4
5function CustomCheckout() {
6  const tds = useThreeDSecure();
7
8  async function handlePayment() {
9    // Create a 3DS session on your backend
10    const sessionId = await create3DSecureSession();
11
12    tds.start(sessionId, {
13      onSuccess: () => {
14        console.log("3DS successful");
15      },
16      onFailure: (error: Error) => {
17        console.error("3DS failed", error);
18      },
19      onError: (error: Error) => {
20        console.warn("3DS errored", error);
21      },
22    });
23  }
24
25  return (
26    <Form>
27      <Button onPress={handlePayment}>Pay</Button>
28
29      <ThreeDSecure state={tds}>
30        <Modal onRequestClose={tds.cancel}>
31          <ThreeDSecure.Frame />
32        </Modal>
33      </ThreeDSecure>
34    </Form>
35  );
36}
```

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

### init

Source: https://docs.evervault.com/sdks/python

Initializes the SDK with your API Key and App ID.

```APIDOC
## init

### Description
Initializes the SDK with your API Key and App ID.

### Method
init

### Parameters
- **app_id** (String) - Required - Your Evervault App's ID.
- **api_key** (String) - Required - Your Evervault App's API Key.

### Request Example
```python
import evervault

evervault.init(
    # Your App's ID
    app_id="<APP_ID>"
    # Your App's API key
    api_key="<API_KEY>",
)
```
```

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

### Perform 3D Secure authentication with ThreeDSecure component

Source: https://docs.evervault.com/sdks/react-native-legacy

Use the ThreeDSecure component in combination with the Evervault API to perform 3DS authentications. You must first create a 3DS session on your backend and pass it to your frontend. The example shows using useThreeDSecure hook, starting a session, handling callbacks, and displaying the ThreeDSecure.Frame in a modal.

```tsx
import {
  ThreeDSecure,
  useThreeDSecure,
} from "@evervault/evervault-react-native";
import { createThreeDSSession, finalizePayment } from "./api";
import { Modal, TouchableOpacity, Text, View } from "react-native";

function Checkout() {
  const tds = useThreeDSecure();

  const handlePayment = async () => {
    // Create a 3DS session on your backend
    const sessionId = await create3DSecureSession();

    tds.start(sessionId, {
      onSuccess: () => {
        console.log("3DS successful");
      },
      onFailure: (error: Error) => {
        console.error("3DS failed", error);
      },
      onError: (error: Error) => {
        console.log("3DS errored", error);
      },
    });
  };

  const close3DS = async () => {
    await tds.cancel();
  };

  return (
    <ThreeDSecure state={tds}>
      <Modal animationType="slide" transparent={true}>
        <View style={[styles.modalContainer]}>
          <View style={[styles.modalContent]}>
            <View style={[styles.titleBar]}>
              <TouchableOpacity style={[styles.closeButton]} onPress={close3DS}>
                <Text style={[styles.closeButtonText]}>"X"</Text>
              </TouchableOpacity>
              <Text style={[styles.titleText]}>"Verification"</Text>
            </View>
            <ThreeDSecure.Frame />
          </View>
        </View>
      </Modal>
    </ThreeDSecure>
  );
}
```

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

### Initialize the SDK with named parameters

Source: https://docs.evervault.com/sdks/python

Initialize the SDK using named parameters for clarity.

```python
import evervault

evervault.init(
    # Your App's ID
    app_id="<APP_ID>"
    # Your App's API key
    api_key="<API_KEY>",
)
```

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

### 1ev enclave env get

Source: https://docs.evervault.com/sdks/cli

Get the environment variables in JSON format.

```APIDOC
## 1ev enclave env get

### Description
Get the environment variables in JSON format.

### Method
CLI Command

### Command
`1ev enclave [FLAGS] env get`
```

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

### Install evervault gem via Gemfile

Source: https://docs.evervault.com/sdks/ruby

Adds the evervault gem to a Gemfile for installation via Bundler.

```ruby
gem 'evervault'
```

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

### Use a prebuilt theme

Source: https://docs.evervault.com/cards/card-collection?backend=node

Creates a card with the clean prebuilt theme. The SDK also provides minimal and material themes.

```javascript
evervault.ui.card({
  theme: evervault.ui.themes.clean(),
});
```

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

### Webhook Endpoint Example

Source: https://docs.evervault.com/developers/webhooks

Example of an Express.js endpoint that receives webhook events and processes them based on event type.

```APIDOC
## POST /evervault

### Description
This endpoint receives webhook events from Evervault. It processes the event based on its type and returns a 2XX status code upon successful processing.

### Method
POST

### Endpoint
/evervault

### Request Body
- `id` (string) - Required - Unique identifier for the event.
- `type` (string) - Required - The type of event that occurred.
- `data` (object) - Required - Event specific data.
- `createdAt` (string) - Required - The timestamp when the event was created.

### Request Example
{
  "id": "evt_123",
  "type": "payments.network-token.updated",
  "data": {},
  "createdAt": "2023-01-01T00:00:00Z"
}

### Response
#### Success Response (200)
- `success` (boolean) - Indicates successful processing.

#### Response Example
{
  "success": true
}
```

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

### Evervault()

Source: https://docs.evervault.com/sdks/java

The SDK constructor takes your App's ID and API key. It initializes the client for standard use with network access.

```APIDOC
## Evervault()

### Description
The SDK constructor takes two parameters; your App's ID and API key.

### Method
Constructor

### Parameters
- **appId** (String) - Required - Your Evervault App's ID.
- **apiKey** (String) - Required - Your Evervault App's API key.

### Request Example
```java
import com.evervault.Evervault;

var evervault = new Evervault("<APP_ID>", "<API_KEY>");
```
```

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

### Initialize Evervault PHP SDK

Source: https://docs.evervault.com/sdks/php

Initialize the SDK with your App ID and API key. Replace placeholders with your actual credentials.

```php
1<?php
2use \Evervault\Evervault;
3
4$evervault = new Evervault('<APP_ID>', '<API_KEY>');
```

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

### Get a rule with curl

Source: https://docs.evervault.com/cards/pre-chargeback-alerts

GET endpoint to retrieve a specific rule. Returns 404 if the rule doesn't exist or doesn't belong to that merchant.

```bash
curl 'https://api.evervault.com/payments/pre-chargeback-alerts/merchants/{merchant_id}/rules/{rule_id}' \
  -u '<app_id>:<api_key>'
```

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

### Initialize SDK and encrypt a string

Source: https://docs.evervault.com/sdks/ruby

Requires the evervault gem, sets the app ID and API key, and encrypts a string.

```ruby
require "evervault"
Evervault.app_id = "<APP_ID>"
Evervault.api_key = "<API_KEY>"

encrypted = Evervault.encrypt("Hello, world!")
```

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

### EvervaultPaymentView Initialization and Delegate Implementation

Source: https://docs.evervault.com/sdks/ios

Shows how to create an EvervaultPaymentView instance, set its delegate, and implement the required and optional delegate methods in a UIViewController.

```APIDOC
## EvervaultPaymentView Initialization and Delegate Implementation

### Description
Initialize an `EvervaultPaymentView` with your Evervault app ID, Apple merchant ID, transaction details, supported networks, and button style/type. Set the delegate to receive payment authorization and completion callbacks.

### Method
Initializer

### Endpoint
`EvervaultPaymentView(appId:appleMerchantId:transaction:supportedNetworks:buttonStyle:buttonType:)`

### Parameters
#### Initializer Parameters
- **appId** (String) - Required - Your Evervault app ID.
- **appleMerchantId** (String) - Required - Your Apple merchant identifier.
- **transaction** (Transaction) - Required - The transaction object built via `buildTransaction()`.
- **supportedNetworks** ([PKPaymentNetwork]) - Required - Array of supported card networks (e.g., `.visa`, `.masterCard`, `.amex`).
- **buttonStyle** (PKPaymentButtonStyle) - Optional - The style of the Apple Pay button (e.g., `.whiteOutline`).
- **buttonType** (PKPaymentButtonType) - Optional - The type of the Apple Pay button (e.g., `.checkout`).

### Delegate Methods
#### Required
- **evervaultPaymentView(_:didAuthorizePayment:)** - Called when a payment is authorized, before the sheet dismisses. Provides the decrypted `ApplePayResponse`.

#### Optional (default no-op implementations)
- **evervaultPaymentView(_:didFinishWithResult:)** - Called when the payment flow finishes with a `Result<Void, EvervaultError>`. Mirrors `onResult`.
- **evervaultPaymentViewDidCancel(_:)** - Called when the payment sheet is cancelled. Mirrors `onCancel`.
- **didDeclinePayment** - Mirrors `onDecline`.
- **shouldAuthorize** - Mirrors `shouldAuthorize`.
- **didSelectShippingContact** - Mirrors `onShippingAddressChange`.
- **didUpdatePaymentMethod** - Mirrors `onPaymentMethodChange`.
- **didChangeCouponCode** - Mirrors `onCouponCodeChange`.
- **didSelectShippingMethod** - Mirrors `onShippingMethodChange`.
- **prepareTransaction** - Mirrors `prepareTransaction`.

### Request Example
```swift
let paymentView = EvervaultPaymentView(
  appId: "YOUR_EVERVAULT_APP_ID",
  appleMerchantId: "YOUR_APPLE_MERCHANT_IDENTIFIER",
  transaction: buildTransaction(),
  supportedNetworks: [.visa, .masterCard, .amex],
  buttonStyle: .whiteOutline,
  buttonType: .checkout
)
paymentView.delegate = self
view.addSubview(paymentView)
```

### Response
#### Success Response
- **applePayResponse** (ApplePayResponse?) - The decrypted payment response, available in `didAuthorizePayment`.

#### Response Example
```swift
func evervaultPaymentView(_ view: EvervaultPaymentView, didAuthorizePayment result: ApplePayResponse?) {
  applePayResponse = result
}
```
```

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

### Card.Expiry component example

Source: https://docs.evervault.com/sdks/react-native

Used as a child of <Card /> to collect the card's expiry date. The example shows Card.Number and Card.Expiry together.

```tsx
import { Card } from "@evervault/react-native";

function CardForm() {
  return (
    <Card>
      <Card.Number />
      <Card.Expiry placeholder="MM / YY" />
    </Card>
  );
}
```

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

### pin.on('ready', callback)

Source: https://docs.evervault.com/sdks/javascript

Fired when the component loads and is ready to be displayed.

```APIDOC
## pin.on('ready', callback)

### Description
Fired when the component loads and is ready to be displayed.

### Method
Event Listener

### Parameters
- **event** (string) - Required - The event name, `'ready'`.
- **callback** (function) - Required - The callback function to execute when the event fires.

### Request Example
```javascript
pin.on("ready", () => {
  document.getElementById("pin-field").style.display = "block";
});
```

```

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

### Initialize the Evervault Python SDK

Source: https://docs.evervault.com/sdks/python

Initialize the SDK with your App ID and API key.

```python
import evervault
evervault.init("<APP_ID>", "<API_KEY>")
```

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

### Pin component usage example

Source: https://docs.evervault.com/sdks/react

Collects and encrypts PIN numbers in a PCI-compliant environment. The example uses the clean theme and logs the change details to the console.

```jsx
import { Pin, themes } from "@evervault/react";
const theme = themes.clean();

export function MyComponent() {
  const handleChange = (details) => {
    console.log(details);
  };

  return (
    <div>
      <Pin theme={theme} onChange={handleChange} />
    </div>
  );
}
```

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

### ev enclave init

Source: https://docs.evervault.com/sdks/cli

Creates an Enclave and initializes an `enclave.toml` in the current directory. Generates a key pair for signing unless explicitly provided.

```APIDOC
## ev enclave init

### Description
Create an Enclave and initialize an `enclave.toml` in the current directory. By default, this will generate a key pair to sign your Enclave image unless a key pair is explicitly provided using `--private-key` and `--signing-cert`.

### Command
`ev enclave [FLAGS] init [OPTIONS] --name <ENCLAVE_NAME>`

### Options
- **--name** (string) - Required - Name of Enclave to deploy.
- **--port** (integer) - Optional - The port that the in-Enclave service listens on. All incoming requests will be forwarded to this port. If unset, it will be taken as last exposed port in the Dockerfile.
- **--file** (string) - Optional - Dockerfile to build the Enclave.
- **--healthcheck** (string) - Optional - The path that should be used for in-Enclave healthchecks. These healthchecks are performed every second and can be used to probe the running process.
- **--healthcheck-port** (integer) - Optional - The port to perform healthchecks against. If this is unset, then the healthchecks are assumed to be served over the same port as the incoming requests.
- **--debug** (boolean) - Optional - Debug setting for the Enclave. When debug is enabled, you can access logs from within the Enclave.
- **--egress** (boolean) - Optional - Flag to enable network egress from your Enclave, default egress port is 443.
- **--egress-destinations** (string) - Optional - Comma separated list of domains to allow egress to, default is all (*).
- **-h, --help** - Optional - Print help information.
- **-o, --output** (string) - Optional - Directory to write the enclave.toml to. Defaults to the current directory.
- **--private-key** (string) - Optional - Path to the signing key to use for the Enclave.
- **--signing-cert** (string) - Optional - Path to the signing cert to use for the Enclave.
- **--disable-api-key-auth** (boolean) - Optional - Turn off API key authentication in the Enclave.
- **--trusted-headers** (string) - Optional - Trusted headers sent into the Enclave will be persisted without redaction in the Enclave's transaction logs.
- **--disable-tls-termination** (boolean) - Optional - Turn off TLS Termination in the Enclave's data plane process. This will allow you to control TLS termination within your service to enable mTLS or a custom certificate.
- **--forward-proxy-protocol** (boolean) - Optional - When supplied with --disable-tls-termination, the data plane will forward the client IP using the HAProxy Proxy Protocol v2.
- **--desired-replicas** (integer) - Optional - Define the number of instances to deploy your Enclave to. Defaults to 2.
- **--max-concurrent-connections** (integer) - Optional - Enable concurrent request processing by capping the number of connections the data plane handles at once. Must be greater than zero. If unset, the data plane accepts connections serially.
- **--max-concurrent-handshakes** (integer) - Optional - The maximum number of TLS handshakes the data plane maintains concurrently. Must be greater than zero and must not exceed --max-concurrent-connections.
- **--handshake-timeout** (integer) - Optional - The timeout for a single TLS handshake, in milliseconds. Stalled handshakes are dropped after the timeout elapses.

### Example
```bash
ev enclave init --name my-enclave
```
```
Tokens:
Raw