> ## Documentation Index
> Fetch the complete documentation index at: https://developers.fireblocks.com/llms.txt
> Use this file to discover all available pages before exploring further.

<AgentInstructions>

## Submitting Feedback

If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:

POST https://developers.fireblocks.com/feedback

```json
{
  "path": "/docs/quickstart",
  "feedback": "Description of the issue"
}
```

Only submit feedback when you have something specific and actionable to report.

</AgentInstructions>

# Getting Started

> Install the Fireblocks Documentation MCP, then use an SDK or the Fireblocks CLI to make your first Fireblocks API calls.

By the end of this guide, you will have:

* Connected your agent to the Fireblocks docs
* Created and approved an API user
* Initialized the Fireblocks SDK or CLI
* Created a vault account
* Sent your first transaction

## Step 0: Connect your AI agent to Fireblocks docs

Before you start, install the **Fireblocks Documentation MCP** so your agent (Cursor, Claude Code, Codex, or other) can access docs in real time to ensure up to date, accurate implementation context.

<Tabs>
  <Tab title="Cursor">
    [Click here to add the Fireblocks Documentation MCP to Cursor.](https://cursor.com/en/install-mcp?name=fireblocks\&config=eyJ1cmwiOiJodHRwczovL2RldmVsb3BlcnMuZmlyZWJsb2Nrcy5jb20vZG9jcy9tY3AifQ==)

    <Tip>
      If the install link doesn't open in your environment, open Cursor's MCP installer manually and point it at `https://www.developers.fireblocks.com/mcp`.
    </Tip>
  </Tab>

  <Tab title="Claude Code">
    ```bash theme={"system"}
    claude mcp add --transport http fireblocks-docs https://www.developers.fireblocks.com/mcp
    ```
  </Tab>

  <Tab title="Codex">
    ```bash theme={"system"}
    codex mcp add --transport http fireblocks-docs https://www.developers.fireblocks.com/mcp
    ```
  </Tab>

  <Tab title="Other">
    Use the Fireblocks Documentation MCP endpoint:

    `https://www.developers.fireblocks.com/mcp`
  </Tab>
</Tabs>

## Step 1: Set up API authentication

Fireblocks authenticates API requests with **JWT signatures**. Each request is signed with an **API secret key** (RSA private key) that stays in your environment. Fireblocks stores only the matching **public key**, which you register when you create the API user by uploading a **Certificate Signing Request (CSR)**.

### How signing works

| Component                        | Location              | Purpose                                               |
| -------------------------------- | --------------------- | ----------------------------------------------------- |
| **API secret key** (private key) | Your environment only | Signs every API request to prove it came from you     |
| **Public key**                   | Fireblocks            | Verifies that requests were signed by your secret key |

Your API secret **never** leaves your environment. Fireblocks only receives your public key. We cannot sign requests on your behalf, and a compromised Fireblocks system would not expose your credentials.

### Generate a CSR and secret key

You will create:

* A **secret key** file that stays in your environment and signs requests
* A **CSR** file containing the corresponding public key, which you upload in the Console

1. (Windows users) Install **Win32OpenSSL** using the default settings.
2. (Windows users) Open OpenSSL Command Prompt.
3. In your CLI, run:

<CodeGroup>
  ```bash Shell theme={"system"}
  openssl req -new -newkey rsa:4096 -nodes -keyout fireblocks_secret.key -out fireblocks.csr -subj '/O=<your_organization>'
  ```
</CodeGroup>

This command creates:

* **fireblocks\_secret.key** — your RSA 4096 private key (API secret)
* **fireblocks.csr** — the CSR you upload when creating the API user

4. Store the secret key file securely.

### Create an API user (API key)

<Info>
  If you’re using a Sandbox environment, you can skip this subsection. Sandboxes come with an API user already created and access to the [Communal Test Co-signer](/reference/use-communal-cosigner#/).
</Info>

To create an API key with a signing role:

1. In the Fireblocks Console, go to **Developer Center** > **API Users**.
2. Select **Add API user**.
3. Name the API user, select the appropriate workspace role for it (e.g., Signer if you want it to sign transactions), and upload the `fireblocks.csr` file you generated above.
4. Select **Add user**.

After the request to add the API user is approved, it will appear in the API users list. You'll receive an **API Key** (API User ID), a unique identifier for the API user that you'll use alongside your secret key.

## Choose your path: SDK or CLI

From **Step 2** onward, the guide splits into two tracks that share the same API credentials. Pick the one that matches what you're building:

* **SDK** — for application code (apps, services, backends) where you ship typed, maintainable Fireblocks integrations. **Recommended for production.**
* **Fireblocks CLI** — for fast workspace operations, exploration, scripts, CI, and operator/agent workflows. Lets your AI agent propose exact commands you can review and run.

Steps **3 through 5** each use two synced tabs. Pick **SDK** or **CLI** once and the choice carries through the rest of the guide. The SDK and CLI are not mutually exclusive; you can use both in the same workspace.

## Step 2: Initialize the SDK or CLI

Pick the tab that matches your track. The same choice will apply to Steps 3–5.

<Tabs>
  <Tab title="SDK">
    Fireblocks provides official SDKs for multiple languages:

    * [TypeScript SDK](https://github.com/fireblocks/ts-sdk)
    * [Python SDK](https://github.com/fireblocks/py-sdk)
    * [Java SDK](/reference/java-sdk#/)

    Install the appropriate SDK for your environment:

    <CodeGroup>
      ```bash npm theme={"system"}
      npm install fireblocks-sdk
      ```

      ```bash pip theme={"system"}
      pip install fireblocks-sdk
      ```

      ```java Java theme={"system"}
      // Follow Java SDK instructions on the documentation link above
      ```
    </CodeGroup>

    After installing the SDK, initialize the client with:

    * Your **API Key** (obtained from the Fireblocks Console after creating the API user)
    * Your **API secret key** (the `fireblocks_secret.key` file from Step 1)

    The SDK uses your secret key to sign each API request automatically.

    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      import { FireblocksSDK } from "fireblocks-sdk";
      import fs from "fs";

      const apiKey = "<YOUR_API_KEY>";
      const privateKey = fs.readFileSync("fireblocks_secret.key", "utf8");

      const fireblocks = new FireblocksSDK(privateKey, apiKey);
      ```

      ```python Python theme={"system"}
      from fireblocks_sdk import FireblocksSDK

      api_key = "<YOUR_API_KEY>"
      with open("fireblocks_secret.key", "r") as f:
          private_key = f.read()

      fireblocks = FireblocksSDK(private_key, api_key)
      ```

      ```java Java theme={"system"}
      import com.fireblocks.sdk.FireblocksSDK;
      import java.nio.file.Files;
      import java.nio.file.Paths;

      String apiKey = "<YOUR_API_KEY>";
      String privateKey = new String(Files.readAllBytes(Paths.get("fireblocks_secret.key")));

      FireblocksSDK fireblocks = new FireblocksSDK(privateKey, apiKey);
      ```
    </CodeGroup>

    Replace `<YOUR_API_KEY>` with your API Key from the Fireblocks Console.
  </Tab>

  <Tab title="CLI">
    Install the Fireblocks CLI (Node.js 18+ required), then connect it to your workspace:

    ```bash theme={"system"}
    npm install -g @fireblocks/fireblocks-cli
    fireblocks --version

    fireblocks configure        # paste API key + path to fireblocks_secret.key
    fireblocks whoami           # verify credentials resolve and authenticate
    ```

    Other installers (Homebrew, standalone binaries, yarn/pnpm) are documented on the [Fireblocks CLI](/docs/fireblocks-cli) page.

    <Tip>
      For agent workflows, your agent should run `fireblocks help-index` once to discover commands, and use `--dry-run` and `--idempotency-key` on writes.
    </Tip>
  </Tab>
</Tabs>

## Step 3: Create a Vault Account

A Vault Account is where your assets are securely stored.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      const vault = await fireblocks.createVaultAccount('My First Vault');
      console.log(vault);
      ```

      ```python Python theme={"system"}
      vault = fireblocks.create_vault_account("My First Vault")
      print(vault)
      ```

      ```java Java theme={"system"}
      var vault = fireblocks.createVaultAccount("My First Vault");
      System.out.println(vault);
      ```
    </CodeGroup>
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    fireblocks vaults create-vault-account \
      --data '{"name":"My First Vault"}' \
      --no-confirm
    ```
  </Tab>
</Tabs>

You can view the new Vault account in the Console under **Accounts** > **Vault**.

<Tip>
  If you’re using a Sandbox, your account should come pre-funded. If you need additional funds, see [Receiving funds into your Fireblocks account](https://support.fireblocks.io/hc/en-us/articles/4414266562450-Receiving-funds-into-your-Fireblocks-accounts) for more information.
</Tip>

## Step 4: Create a Transaction

Now that your vault has funds, you can create your first transaction.

<Tabs>
  <Tab title="SDK">
    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      const transaction = await fireblocks.createTransaction({
        assetId: 'ETH_TEST',
        source: { type: 'VAULT_ACCOUNT', id: vault.id },
        destination: { type: 'EXTERNAL_WALLET', id: '<YOUR_WALLET_ID>' },
        amount: '0.01',
      });
      console.log(transaction);
      ```

      ```python Python theme={"system"}
      transaction = fireblocks.create_transaction({
          "assetId": "ETH_TEST",
          "source": { "type": "VAULT_ACCOUNT", "id": vault["id"] },
          "destination": { "type": "EXTERNAL_WALLET", "id": "<YOUR_WALLET_ID>" },
          "amount": "0.01"
      })
      print(transaction)
      ```

      ```java Java theme={"system"}
      var txRequest = new TransactionRequest();
      txRequest.setAssetId("ETH_TEST");
      txRequest.setSource(new Source("VAULT_ACCOUNT", vault.getId()));
      txRequest.setDestination(new Destination("EXTERNAL_WALLET", "<YOUR_WALLET_ID>"));
      txRequest.setAmount("0.01");

      var tx = fireblocks.createTransaction(txRequest);
      System.out.println(tx);
      ```
    </CodeGroup>
  </Tab>

  <Tab title="CLI">
    Preview the request first with `--dry-run`, then execute with an idempotency key so safe retries don't create duplicate transactions:

    ```bash theme={"system"}
    # Preview
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST","amount":"0.01","source":{"type":"VAULT_ACCOUNT","id":"0"},"destination":{"type":"EXTERNAL_WALLET","id":"<YOUR_WALLET_ID>"}}' \
      --dry-run

    # Execute
    fireblocks transactions create-transaction \
      --data '{"assetId":"ETH_TEST","amount":"0.01","source":{"type":"VAULT_ACCOUNT","id":"0"},"destination":{"type":"EXTERNAL_WALLET","id":"<YOUR_WALLET_ID>"}}' \
      --idempotency-key "$(uuidgen)" \
      --no-confirm
    ```
  </Tab>
</Tabs>

## Step 5: Verify Transactions

To verify your transaction status, use the following.

<Tabs>
  <Tab title="SDK">
    For Fireblocks transactions:

    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      const tx = await fireblocks.getTransactionById(txId);
      ```

      ```python Python theme={"system"}
      tx = fireblocks.get_transaction_by_id(txId)
      ```

      ```java Java theme={"system"}
      var tx = getTransactionById(String txId);
      ```
    </CodeGroup>

    For external transactions:

    <CodeGroup>
      ```typescript TypeScript theme={"system"}
      const tx = await fireblocks.getTransactionByExternalTxId(externalTxId);
      ```

      ```python Python theme={"system"}
      tx = fireblocks.get_transaction_by_external_tx_id(externalTxId)
      ```

      ```java Java theme={"system"}
      var tx = getTransactionByExternalTxId(String externalTxId);
      ```
    </CodeGroup>
  </Tab>

  <Tab title="CLI">
    ```bash theme={"system"}
    # By Fireblocks transaction ID
    fireblocks transactions get-transaction --tx-id <TX_ID> --json

    # By external transaction ID
    fireblocks transactions get-transaction-by-external-id \
      --external-tx-id <EXTERNAL_TX_ID> --json
    ```
  </Tab>
</Tabs>

## Next Steps

**CLI**

* [Fireblocks CLI](/docs/fireblocks-cli) — install, overview, and quick start
* [CLI Authentication](/docs/cli-authentication) — credentials, profiles, and environment variables
* [CLI Usage](/docs/cli-usage) — commands, flags, exit codes, and examples

**SDKs**

* [TypeScript SDK](/reference/typescript-sdk)
* [Python SDK](/reference/new-python-sdk)
* [Java SDK](/reference/java-sdk)

**API and platform**

* [API Reference](/reference/api-overview) — REST endpoints and request bodies
* [Manage API keys](/docs/manage-api-keys) — CSR flow, roles, and rotation
* Automate transaction signing with [API co-signers](/docs/use-cosigners-for-signing-automation#/)
* Real-time updates with [webhooks](/reference/webhooks-gettingstarted-configuringwebhooks#/)