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

# MPC Quickstart

> Go from install to a signed and broadcast transaction in a few steps.

This is the fastest path to a working self-custodial wallet. No seed phrase. You hold the wallet and the WalletSuite signing service holds a co-signing share, so both are needed to sign. A few steps and you have a signed transaction on chain.

## Prerequisites

* A WalletSuite API key with wallet signing access. See [Credentials & Authentication](/getting-started/prerequisites/credentials-and-authentication).
* The SDK runtime for your language. See the [SDK reference](/mpc/sdk-reference) for available runtimes.

```bash theme={null}
export WALLETSUITE_API_KEY="your-api-key"
```

## Steps

<Steps>
  <Step title="Install the SDK">
    Add the WalletSuite wallet SDK to your project.

    <CodeGroup>
      ```bash Node theme={null}
      npm install @walletsuite/wallet
      ```

      ```bash Python theme={null}
      pip install walletsuite-wallet
      ```
    </CodeGroup>
  </Step>

  <Step title="Create your wallet">
    Create an SDK client pointed at the WalletSuite signing service and pass your API key.

    Creating the wallet returns the wallet blob. Save it to your own storage before you continue, since you hold it and WalletSuite does not.

    <CodeGroup>
      ```js wallet.js theme={null}
      const { MpcClient } = require("@walletsuite/wallet");

      const client = new MpcClient(
        "https://cosigner.walletsuite.io",
        process.env.WALLETSUITE_API_KEY
      );

      const wallet = await client.createWallet();
      await saveWallet(wallet); // your storage
      ```

      ```python wallet.py theme={null}
      import os
      import walletsuite_wallet as ws

      client = ws.MpcClient(
          "https://cosigner.walletsuite.io",
          api_key=os.environ["WALLETSUITE_API_KEY"],
      )

      wallet = client.create_wallet()
      save_wallet(wallet)  # your storage
      ```
    </CodeGroup>

    <Note>
      Persist the wallet to durable storage you control, never a temp directory, and keep a secure backup. Your backup is your recovery. It is 2-of-2 by default. For storage patterns, see [Shares & thresholds](/mpc/key-shares).
    </Note>
  </Step>

  <Step title="Derive an address">
    Turn the wallet into an on-chain address. This runs locally with no network call. One wallet works everywhere, so the same wallet derives addresses across 84 chains.

    <CodeGroup>
      ```js wallet.js theme={null}
      const address = client.deriveAddress(wallet, "base");
      ```

      ```python wallet.py theme={null}
      address = client.derive_address(wallet, "base")
      ```
    </CodeGroup>

    <Tip>
      One wallet covers every chain. Pass it to `deriveAddress` for any of them. See [One wallet, every chain](/mpc/curves).
    </Tip>
  </Step>

  <Step title="Sign the transaction">
    Sign with `signEvm7702`, which signs the EIP-7702 (type-4) smart-account transaction format and returns it ready to broadcast.

    Each signature is authorized automatically: the SDK mints a single-use, payload-bound signing intent for you, so you pass only the transfer. See [Signing intents](/mpc/signing-intents) for how that works under the hood.

    | Argument group                                              | Type                                              |
    | ----------------------------------------------------------- | ------------------------------------------------- |
    | Amounts and per-gas fees (value, max priority fee, max fee) | wei. Decimal strings in Node, integers in Python. |
    | chain id, nonce, gas limit                                  | plain numbers                                     |

    <CodeGroup>
      ```js wallet.js theme={null}
      const signed = await client.signEvm7702(
        wallet,
        8453,                            // chain id (Base)
        0,                               // nonce
        "0xRecipientAddress",
        "1000000000000",                 // value, wei
        "1000000000",                    // max priority fee per gas, wei
        "2000000000",                    // max fee per gas, wei
        300000,                          // gas limit
        null,                            // token (null for native)
        null,                            // data
        null,                            // delegate
        null                             // path
      );

      signed.raw; // broadcast-ready transaction
      ```

      ```python wallet.py theme={null}
      signed = client.sign_evm_7702(
          wallet,
          8453,                              # chain id (Base)
          0,                                 # nonce
          "0xRecipientAddress",
          1_000_000_000_000,                 # value, wei
          1_000_000_000,                     # max priority fee per gas, wei
          2_000_000_000,                     # max fee per gas, wei
          300_000,                           # gas limit
      )

      signed.raw  # broadcast-ready transaction
      ```
    </CodeGroup>

    <Note>
      The SDK signs but does not broadcast, so send the result in the next step. For more signing paths, see [Signing](/mpc/signing).
    </Note>
  </Step>

  <Step title="Broadcast the transaction">
    Submit the signed transaction. Use your own RPC, or `POST` the raw transaction to WalletSuite and check status by hash. See the send endpoint reference at [https://api.walletsuite.io/docs#tag/transactions/POST/api/txs/send](https://api.walletsuite.io/docs#tag/transactions/POST/api/txs/send).

    <CodeGroup>
      ```bash Send theme={null}
      curl -X POST "https://api.walletsuite.io/api/txs/send" \
        -H "x-api-key: $WALLETSUITE_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{ "chain": "base", "signedTx": "0x..." }'
      ```

      ```bash Status theme={null}
      curl "https://api.walletsuite.io/api/txs/status/0xTransactionHash?chain=base" \
        -H "x-api-key: $WALLETSUITE_API_KEY"
      ```
    </CodeGroup>

    For confirmation handling and event-driven delivery, see [Broadcasting](/mpc/broadcasting). To react to confirmed transfers without polling, see [Webhooks](/webhooks/overview).
  </Step>
</Steps>

## Next steps

<CardGroup cols={2}>
  <Card title="End-to-end walkthrough" icon="route" href="/mpc/end-to-end">
    The complete journey from wallet creation to a confirmed transaction.
  </Card>

  <Card title="Signing intents" icon="ticket" href="/mpc/signing-intents">
    How every signature is pre-authorized under the hood, with nothing to implement.
  </Card>

  <Card title="Signing" icon="signature" href="/mpc/signing">
    Every signing path across 84 chains.
  </Card>

  <Card title="Broadcasting" icon="paper-plane" href="/mpc/broadcasting">
    Submit signed transactions through WalletSuite or your own RPC, and track confirmation.
  </Card>
</CardGroup>