Turnkey API Reference

https://docs.turnkey.com/api-reference/
Admin
Turnkey provides an API for secure management of cryptographic keys, wallets, user authentication,...
Tokens:528,997
Snippets:1,882
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get Boot Proof using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-a-specific-boot-proof

This JavaScript example demonstrates how to use the Turnkey SDK to call the getBootProof method. It requires initializing the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getBootProof({
  organizationId: "<string> (Unique identifier for a given Organization.)",
  ephemeralKey: "<string> (Hex encoded ephemeral public key.)"
});
```

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

### Get User Request (JavaScript SDK)

Source: https://docs.turnkey.com/api-reference/queries/get-user

This JavaScript example demonstrates how to use the Turnkey SDK to fetch user details. Initialize the client with your API credentials and organization ID, then call the getUser method.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getUser({
  organizationId: "<string> (Unique identifier for a given organization.)",
  userId: "<string> (Unique identifier for a given user.)"
});
```

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

### Get Account Request Example

Source: https://docs.turnkey.com/api-reference/auth-proxy/account

Use this command to make a GET request to the /v1/account endpoint. Ensure you replace placeholder values with your actual configuration and tokens. The X-Auth-Proxy-Config-Id header is crucial for authorization.

```bash
--url https://authproxy.turnkey.com/v1/account \
    --header 'Accept: application/json' \
    --header 'Content-Type: application/json' \
    --header "X-Auth-Proxy-Config-Id: <string> (see Authorizations)" \
    --data '{ \
      "filterType": "<string>", \
      "filterValue": "<string>", \
      "verificationToken": "<string>", \
      "oidcToken": "<string>" \
  }'
```

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

### Get Smart Contract Interface using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-smart-contract-interface

This JavaScript example demonstrates how to use the Turnkey SDK to fetch smart contract interface details. It requires initializing the Turnkey client with your API keys and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getSmartContractInterface({
  organizationId: "<string> (Unique identifier for a given organization.)",

```

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

### Get Organization Configs using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-configs

This JavaScript example demonstrates how to use the Turnkey SDK to fetch organization configurations. Initialize the Turnkey client with your API credentials and organization ID. The organizationId parameter is required for the request.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getOrganizationConfigs({
  organizationId: "<string> (Unique identifier for a given organization.)"
});
```

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

### Signup Request Example (cURL)

Source: https://docs.turnkey.com/api-reference/auth-proxy/signup

Example of how to make a signup request using cURL. Ensure to replace placeholder values with your actual data.

```bash
curl --request POST \
  --url https://authproxy.turnkey.com/v1/signup_v2 \
  --header 'Accept: application/json' \
  --header 'Content-Type: application/json' \
  --header "X-Auth-Proxy-Config-Id: <string> (see Authorizations)" \
  --data '{ 
    "userEmail": "<string>",
    "userPhoneNumber": "<string>",
    "userTag": "<string>",
    "userName": "<string>",
    "organizationName": "<string>",
    "verificationToken": "<string>",
    "apiKeys": [
        {
            "apiKeyName": "<string>",

```

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

### Create Policies Request and Response Example

Source: https://docs.turnkey.com/api-reference/activities/create-policies

This example shows the structure of a request to create policies and the corresponding response, including policy IDs.

```json
{
  "jsonrpc": "2.0",
  "id": "<string>",
  "method": "turnkey_createPolicies",
  "params": {
    "pluginId": "<string>",
    "policy": {
      "version": "<string>",
      "description": "<string>",
      "actions": [
        {
          "type": "<string>",
          "conditions": [
            {
              "type": "<string>",
              "condition": "<string>",
              "consensus": "<string>",
              "notes": "<string>"
            }
          ]
        }
      ]
    }
  }
}
{
  "jsonrpc": "2.0",
  "result": {
    "createPoliciesResult": {
      "policyIds": [
        "<string>"
      ]
    }
  },
  "id": "<string>",
  "votes": "<array>",
  "fingerprint": "<string>",
  "canApprove": "<boolean>",
  "canReject": "<boolean>",
  "createdAt": "<string>",
  "updatedAt": "<string>"
}
```

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

### Get Account Response Example

Source: https://docs.turnkey.com/api-reference/auth-proxy/account

This is an example of a successful JSON response when retrieving account information. The response contains the organizationId.

```json
{
  "organizationId": "<string>"
}
```

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

### List Supported Assets using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/list-supported-assets

This JavaScript example demonstrates how to use the Turnkey SDK to call the `listSupportedAssets` function. It requires initializing the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().listSupportedAssets({
  organizationId: "<string> (Unique identifier for a given organization.)",
  caip2: "<eip155:1>" // CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet or 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp' for Solana mainnet). Human-readable Solana aliases ('solana:mainnet', 'solana:devnet') are also accepted and normalized to canonical CAIP-2 values.
});
```

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

### Get Wallet Response Example

Source: https://docs.turnkey.com/api-reference/queries/get-wallet

A successful response from the Get Wallet endpoint will return a JSON object containing wallet details.

```json
{
  "wallet": {
    "walletId": "<string>",
    "walletName": "<string>",
    "createdAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    },
    "updatedAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    },
    "exported": "<boolean>",
    "imported": "<boolean>"
  }
}
```

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

### Create Wallet Accounts using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/activities/create-wallet-accounts

This JavaScript example demonstrates how to use the Turnkey SDK to create wallet accounts. It requires setting up the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().createWalletAccounts({
  walletId: "<string> (Unique identifier for a given Wallet.)",
  accounts: [{ // A list of wallet Accounts.,
    curve: "<CURVE_SECP256K1>" // curve field,
    pathFormat: "<PATH_FORMAT_BIP32>" // pathFormat field,
    path: "<string> (Path used to generate a wallet Account.)",
    addressFormat: "<ADDRESS_FORMAT_UNCOMPRESSED>" // addressFormat field,
  }],
  persist: true // Indicates if the wallet accounts should be persisted. This is helpful if you'd like to see the addresses of different derivation paths without actually creating the accounts. Defaults to true.
});
```

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

### Request Example for Get Smart Contract Interface

Source: https://docs.turnkey.com/api-reference/queries/get-smart-contract-interface

This snippet shows the structure of a request to get a smart contract interface, requiring the smartContractInterfaceId.

```json
{
  "smartContractInterfaceId": "<string> (Unique identifier for a given smart contract interface.)"
}
```

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

### Get TVC Deployment Request

Source: https://docs.turnkey.com/api-reference/queries/get-tvc-deployment

Example of how to make a request to get a TVC deployment. Ensure you include the necessary headers and the organization and deployment IDs.

```shell
--header 'Accept: application/json' \
    --header 'Content-Type: application/json' \
    --header "X-Stamp: <string> (see Authorizations)" \
    --data '{ \
      "organizationId": "<string>", \
      "deploymentId": "<string>" \
  }'
```

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

### Create Wallet using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/activities/create-wallet

This JavaScript example demonstrates how to create a wallet using the Turnkey SDK. Initialize the client with your API credentials and organization ID, then call the `createWallet` method with the desired parameters.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().createWallet({
  walletName: "<string> (Human-readable name for a Wallet.)",
  accounts: [{ // A list of wallet Accounts. This field, if not needed, should be an empty array in your request body.,
    curve: "<CURVE_SECP256K1>" // curve field,
    pathFormat: "<PATH_FORMAT_BIP32>" // pathFormat field,
    path: "<string> (Path used to generate a wallet Account.)",
    addressFormat: "<ADDRESS_FORMAT_UNCOMPRESSED>" // addressFormat field,
  }],
  mnemonicLength: 0 // Length of mnemonic to generate the Wallet seed. Defaults to 12. Accepted values: 12, 15, 18, 21, 24.
});
```

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

### Signup API Request Example

Source: https://docs.turnkey.com/api-reference/auth-proxy/signup

This example shows the structure of a signup API request, including details for API keys, authenticators, OAuth providers, wallet configuration, and client signatures.

```json
{
    "organizationId": "<string>",
    "email": "<string>",
    "password": "<string>",
    "apiKey": {
        "publicKey": "<string>",
        "curveType": "<API_KEY_CURVE_P256>",
        "expirationSeconds": "<string>"
    },
    "authenticators": [
        {
            "authenticatorName": "<string>",
            "challenge": "<string>",
            "attestation": {
                "credentialId": "<string>",
                "clientDataJson": "<string>",
                "attestationObject": "<string>",
                "transports": [
                    "<AUTHENTICATOR_TRANSPORT_BLE>"
                ]
            }
        }
    ],
    "oauthProviders": [
        {
            "providerName": "<string>",
            "oidcToken": "<string>",
            "oidcClaims": {
                "iss": "<string>",
                "sub": "<string>",
                "aud": "<string>"
            }
        }
    ],
    "wallet": {
        "walletName": "<string>",
        "accounts": [
            {
                "curve": "<CURVE_SECP256K1>",
                "pathFormat": "<PATH_FORMAT_BIP32>",
                "path": "<string>",
                "addressFormat": "<ADDRESS_FORMAT_UNCOMPRESSED>"
            }
        ],
        "mnemonicLength": "<number>"
    },
    "clientSignature": {
        "publicKey": "<string>",
        "scheme": "<CLIENT_SIGNATURE_SCHEME_API_P256>",
        "message": "<string>",
        "signature": "<string>"
    }
}
```

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

### Create Policies using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/activities/create-policies

This JavaScript example demonstrates how to use the Turnkey SDK to create policies. Ensure your API keys and organization ID are correctly configured.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
    apiBaseUrl: "https://api.turnkey.com",
    apiPublicKey: process.env.API_PUBLIC_KEY!,
    apiPrivateKey: process.env.API_PRIVATE_KEY!,
    defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().createPolicies({
    policies: [{"policyName": "<string> (Human-readable name for a Policy.)", "effect": "<EFFECT_ALLOW>" // effect field, "condition": "<string> (The condition expression that triggers the Effect)", "consensus": "<string> (The consensus expression that triggers the Effect)", "notes": "<string> (Notes for a Policy.)"}]
});
```

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

### Successful Get Policy Response

Source: https://docs.turnkey.com/api-reference/queries/get-policy

Example of a successful JSON response when retrieving a policy. It includes detailed fields about the policy's configuration and metadata.

```json
{
  "policy": {
    "policyId": "<string>",
    "policyName": "<string>",
    "effect": "<EFFECT_ALLOW>",
    "createdAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    },
    "updatedAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    },
    "notes": "<string>",
    "consensus": "<string>",
    "condition": "<string>"
  }
}
```

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

### Successful Get Authenticator Response

Source: https://docs.turnkey.com/api-reference/queries/get-authenticator

This is an example of a successful JSON response when retrieving authenticator details. It includes information about the authenticator's transports, attestation type, credential ID, and timestamps.

```json
{
  "authenticator": {
    "transports": [
      "<AUTHENTICATOR_TRANSPORT_BLE>"
    ],
    "attestationType": "<string>",
    "aaguid": "<string>",
    "credentialId": "<string>",
    "model": "<string>",
    "credential": {
      "publicKey": "<string>",
      "type": "<CREDENTIAL_TYPE_WEBAUTHN_AUTHENTICATOR>"
    },
    "authenticatorId": "<string>",
    "authenticatorName": "<string>",
    "createdAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    },
    "updatedAt": {
      "seconds": "<string>",
      "nanos": "<string>"
    }
  }
}
```

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

### List Wallet Accounts using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/list-wallets-accounts

This JavaScript example demonstrates how to use the Turnkey SDK to fetch wallet accounts. It shows how to initialize the client and call the getWalletAccounts method, including optional parameters for wallet details and pagination.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getWalletAccounts({
  organizationId: "<string> (Unique identifier for a given organization.)",
  walletId: "<string> (Unique identifier for a given wallet. If not provided, all accounts for the organization will be returned.)",
  includeWalletDetails: true // Optional flag to specify if the wallet details should be included in the response. Default = false.,
  paginationOptions: { // paginationOptions field,

```

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

### Signup API Response Example

Source: https://docs.turnkey.com/api-reference/auth-proxy/signup

This example illustrates a successful signup API response, including organization ID, wallet details, user ID, and application proofs.

```json
{
  "organizationId": "<string>",
  "wallet": {
    "walletId": "<string>",
    "addresses": [
      "<string>"
    ]
  },
  "userId": "<string>",
  "appProofs": [
    {
      "scheme": "<SIGNATURE_SCHEME_EPHEMERAL_KEY_P256>",
      "publicKey": "<string>",
      "proofPayload": "<string>",
      "signature": "<string>"
    }
  ]
}
```

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

### Get Authenticators using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-authenticators

This JavaScript example demonstrates how to use the Turnkey SDK to fetch authenticators for a user. Initialize the Turnkey client with your API credentials and then call the getAuthenticators method.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getAuthenticators({
  organizationId: "<string> (Unique identifier for a given organization.)",
  userId: "<string> (Unique identifier for a given user.)"
});
```

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

### Initialize Turnkey Client and Perform OTP Login

Source: https://docs.turnkey.com/api-reference/activities/login-with-otp

This snippet demonstrates how to initialize the Turnkey client with your API credentials and then initiate an OTP login process. Ensure you have your API keys and organization ID set as environment variables. The `otpLogin` method requires a signed verification token, the user's public key, and a client signature.

```typescript
import {
  Turnkey
} from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().otpLogin({
  verificationToken: "<string> (Signed Verification Token containing a unique id, expiry, verification type, contact)",
  publicKey: "<string> (Client-side public key generated by the user, used as the session public key upon successful login)",
  clientSignature: {
    publicKey: "<string> (The public component of a cryptographic key pair used to create the signature.)",
    scheme: "CLIENT_SIGNATURE_SCHEME_API_P256",
    message: "<string> (The message that was signed.)",
    signature: "<string> (The cryptographic signature over the message.)"
  },
  expirationSeconds: "<string> (Expiration window (in seconds) indicating how long the Session is valid for. If not provided, a default of 15 minutes will be used.)",
  invalidateExisting: true
});
```

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

### JavaScript SDK Example

Source: https://docs.turnkey.com/api-reference/queries/who-am-i

This JavaScript snippet demonstrates how to use the Turnkey SDK to call the 'whoami' endpoint. It requires initializing the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getWhoami({
  organizationId: "<string> (Unique identifier for a given organization. If the request is being made by a WebAuthN user and their sub-organization ID is unknown, this can be the parent organization ID; using the sub-organization ID when possible is preferred due to performance reasons.)"
});
```

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

### Get Oauth Providers using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-oauth-providers

Shows how to fetch OAuth providers using the Turnkey JavaScript SDK. This example requires setting up the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getOauthProviders({
  organizationId: "<string> (Unique identifier for a given organization.)",
  userId: "<string> (Unique identifier for a given user.)"
});
```

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

### Create Policy using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/activities/create-policy

This JavaScript example demonstrates how to create a policy using the Turnkey SDK. Ensure your Turnkey client is initialized with the correct API keys and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().createPolicy({
  policyName: "<string> (Human-readable name for a Policy.)",
  effect: "<EFFECT_ALLOW>" // effect field,
  condition: "<string> (The condition expression that triggers the Effect)",
  consensus: "<string> (The consensus expression that triggers the Effect)",
  notes: "<string> (Notes for a Policy.)"
});
```

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

### Get Nonces using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-nonces

This JavaScript example demonstrates how to use the Turnkey SDK to call the `getNonces` method. It requires initializing the SDK with your API keys and then calling the method with the appropriate parameters.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
    apiBaseUrl: "https://api.turnkey.com",
    apiPublicKey: process.env.API_PUBLIC_KEY!,
    apiPrivateKey: process.env.API_PRIVATE_KEY!,
    defaultOrganizationId: process.env.ORGANIZATION_ID!,
  });

  const response = await turnkeyClient.apiClient().getNonces({
    organizationId: "<string> (Unique identifier for a given Organization.)",
    address: "<string> (The Ethereum address to query nonces for.)",
    caip2: "<eip155:1>" // CAIP-2 chain ID (e.g., 'eip155:1' for Ethereum mainnet).,
    nonce: true // Whether to fetch the standard on-chain nonce.,
    gasStationNonce: true // Whether to fetch the gas station nonce used for sponsored transactions.
  });
```

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

### Get IP Allowlist using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-ip-allowlist

This JavaScript example demonstrates how to use the Turnkey SDK to call the getIpAllowlist method. It requires initializing the Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getIpAllowlist({
  organizationId: "<string> (Unique identifier for a given organization.)",
  publicKey: "<string> (If provided, return only the allowlist for this specific API key.)"
});
```

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

### List Wallets using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/list-wallets

This JavaScript example demonstrates how to use the Turnkey SDK to fetch a list of wallets. Ensure your API keys and organization ID are correctly configured in the Turnkey client.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getWallets({
  organizationId: "<string> (Unique identifier for a given organization.)"
});
```

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

### Init OTP Response Example

Source: https://docs.turnkey.com/api-reference/activities/init-generic-otp

This is an example of a successful response when initializing an OTP. It includes the activity details and the result containing the OTP ID and encryption bundle.

```json
{
  "activity": {
    "id": "<activity-id>",
    "status": "ACTIVITY_STATUS_COMPLETED",
    "type": "ACTIVITY_TYPE_INIT_OTP_V3",
    "organizationId": "<organization-id>",
    "timestampMs": "<timestamp> (e.g. 1746736509954)",
    "result": {
      "activity": {
        "id": "<string>",
        "organizationId": "<string>",
        "status": "<string>",
        "type": "<string>",
        "intent": {
          "initOtpIntentV3": {
            "otpType": "<string>",
            "contact": "<string>",
            "appName": "<string>",
            "otpLength": "<number>",
            "emailCustomization": {
              "logoUrl": "<string>",
              "magicLinkTemplate": "<string>",
              "templateVariables": "<string>",
              "templateId": "<string>"
            },
            "smsCustomization": {
              "template": "<string>"
            },
            "userIdentifier": "<string>",
            "sendFromEmailAddress": "<string>",
            "alphanumeric": "<boolean>",
            "sendFromEmailSenderName": "<string>",
            "expirationSeconds": "<string>",
            "replyToEmailAddress": "<string>"
          }
        },
        "result": {
          "initOtpResultV2": {
            "otpId": "<string>",
            "otpEncryptionTargetBundle": "<string>"
          }
        },
        "votes": "<array>",
        "fingerprint": "<string>",
        "canApprove": "<boolean>",
        "canReject": "<boolean>",
        "createdAt": "<string>",
        "updatedAt": "<string>"
      }
    }
  }
}
```

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

### Get Gas Usage with JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-gas-usage

This JavaScript example demonstrates how to use the Turnkey SDK to fetch gas usage. Initialize the Turnkey client with your API credentials and organization ID, then call the getGasUsage method.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
    apiBaseUrl: "https://api.turnkey.com",
    apiPublicKey: process.env.API_PUBLIC_KEY!,
    apiPrivateKey: process.env.API_PRIVATE_KEY!,
    defaultOrganizationId: process.env.ORGANIZATION_ID!,
  });

  const response = await turnkeyClient.apiClient().getGasUsage({
    organizationId: "<string> (Unique identifier for a given Organization.)"
  });
```

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

### Initiate OTP Authentication (JavaScript)

Source: https://docs.turnkey.com/api-reference/activities/otp-auth

Use the Turnkey SDK for JavaScript to initiate an OTP authentication. This example shows how to configure the client and call the `otpAuth` method with required parameters like `otpId`, `otpCode`, and `targetPublicKey`.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().otpAuth({
  otpId: "<string> (ID representing the result of an init OTP activity.)",
  otpCode: "<string> (OTP sent out to a user's contact (email or SMS))",
  targetPublicKey: "<string> (Client-side public key generated by the user, to which the OTP bundle (credentials) will be encrypted.)",
  apiKeyName: "<string> (Optional human-readable name for an API Key. If none provided, default to OTP Auth - <Timestamp>)",
  expirationSeconds: "<string> (Expiration window (in seconds) indicating how long the API key is valid for. If not provided, a default of 15 minutes will be used.)",
  invalidateExisting: true // Invalidate all other previously generated OTP Auth API keys
});
```

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

### Get Send Transaction Status using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/queries/get-send-transaction-status

This JavaScript example demonstrates how to use the Turnkey SDK to retrieve the status of a send transaction. It requires initializing the Turnkey client with your API keys and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().getSendTransactionStatus({
  organizationId: "<string> (Unique identifier for a given organization.)",
  sendTransactionStatusId: "<string> (The unique identifier of a send transaction request.)"
});
```

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

### Import Private Key using JavaScript SDK

Source: https://docs.turnkey.com/api-reference/activities/import-private-key

This JavaScript example demonstrates how to use the Turnkey SDK to import a private key. Configure your Turnkey client with your API credentials and organization ID.

```javascript
import { Turnkey } from "@turnkey/sdk-server";

const turnkeyClient = new Turnkey({
  apiBaseUrl: "https://api.turnkey.com",
  apiPublicKey: process.env.API_PUBLIC_KEY!,
  apiPrivateKey: process.env.API_PRIVATE_KEY!,
  defaultOrganizationId: process.env.ORGANIZATION_ID!,
});

const response = await turnkeyClient.apiClient().importPrivateKey({
  userId: "<string> (The ID of the User importing a Private Key.)",
  privateKeyName: "<string> (Human-readable name for a Private Key.)",
  encryptedBundle: "<string> (Bundle containing a raw private key encrypted to the enclave's target public key.)",
  curve: "<CURVE_SECP256K1>" // curve field,
  addressFormats: "<ADDRESS_FORMAT_UNCOMPRESSED>" // Cryptocurrency-specific formats for a derived address (e.g., Ethereum).
});
```
Tokens:
Raw