Using Circle Developer Controlled Wallets to Send and Manage USDC

Intro

Tired of juggling keys and wallets just to move a stablecoin? Here’s how to create, fund, and send USDC entirely from your backend using Circle Developer-Controlled Wallets.

Hi, I’m Elton, and I work on the Developer Relations team at Circle.

Welcome back to Stablecoin one hundred one, a series by Circle where we break down the foundations of stablecoins and how they are powering the new internet financial system.

In our last video, we introduced Circle Wallets, explained their core functions, and looked at the three wallet models you can build with: Developer-Controlled, User-Controlled, and Modular.

In this video, we’re going hands-on with Developer-Controlled Wallets and walking through how to:

• set up your project
• generate and register your entity secret
• create and fund wallets
• send a USDC transaction on Ethereum Sepolia

So whether you’re building a payout platform, treasury automation, or custom finance flows, this is the foundation you need to program USDC at scale—while Circle securely handles multi-party computation (MPC) signing behind the scenes.

---

Step 1: Create the project

First, create a folder. I’ll call mine CircleDCWDemo, but feel free to use any name you like.

Then initialize a new Node.js project.

Now install the packages you need. This includes:

• the Circle Developer-Controlled Wallets SDK
• viem for blockchain RPC calls
• dotenv for managing environment variables

Once that’s done, open the folder in your editor. I’m using Visual Studio Code.

Next, open package.json and change the type from commonjs to module. This allows you to use modern import statements in your scripts.

---

Step 2: Create an API key

Now we’re ready to connect to Circle Developer-Controlled Wallets.

We’ll start by generating an API key and setting up your entity secret, which acts like a secure sign-in credential.

To generate your API key, head over to the Circle Console (console.circle.com) and log in.

In the sidebar, go to API and Client Keys and click Generate Key.

Once created, copy the full API key.

In the root of your project, create a .env file and paste in your API key.

We’ll come back to this file later to add more environment variables.

---

Step 3: Generate an entity secret

Next, generate an entity secret.

The entity secret is a cryptographic key you use to authenticate your API requests. It stays with you—like your own private credential.

Create a script called generateSecret.ts, then run it using npx tsx.

This outputs a brand-new entity secret. Copy it and add it to your .env file.

---

Step 4: Register the entity secret and save the recovery file

Last but not least, register the entity secret with Circle and download a recovery file.

This recovery file is your only backup of the secret. Circle doesn’t store it, and you won’t be able to recover or regenerate it later—so store it securely.

Create another script called registerSecret.ts, then run it.

If everything worked, you’ll see a recovery file saved in your project directory.

At this point, you have:

• set up your .env
• generated your entity secret
• registered it with Circle
• saved the recovery file

Now we’re ready to initialize the SDK.

---

Step 5: Initialize the SDK

Create a new script called walletDemo.ts.

In this file, import the SDK and initialize the Developer-Controlled Wallets client using the credentials from your .env.

Run it. If you see “SDK initialized”, you’re ready for the next step.

---

Step 6: Create a wallet set

Now, create a wallet set.

You can think of a wallet set as a group of wallets that share the same cryptographic key. This lets them use the same wallet address across multiple EVM chains, which makes cross-chain development much easier.

Add this to walletDemo.ts and run it.

---

Step 7: Create two smart contract wallets on Sepolia

Next, create two smart contract wallets on the Ethereum Sepolia testnet—both fully managed from your backend.

If you’re not yet familiar with Sepolia: it’s a test environment for Ethereum. You can create and interact with wallets like you would on mainnet, without spending real ETH.

Add the wallet creation step to the same script and run it again.

You should now have:

• Wallet A
• Wallet B

Both are programmable smart contract wallets controlled from your backend.

---

Step 8: Fund Wallet A (Sepolia ETH + USDC)

Before testing transactions, fund Wallet A with Sepolia ETH and USDC.

Go back to the Circle Console. In the left sidebar, open the Faucet.

In the Wallet ID field, paste the Wallet A ID from your terminal output. Then select Sepolia ETH and USDC, and click Send Tokens.

After a few seconds, you’ll see testnet ETH and USDC deposited into Wallet A.

To confirm the balance, you can:

• check in the Circle Console under Wallets
• or check on Sepolia Etherscan by searching for Wallet A’s address and viewing token transfers

---

Step 9: Send 1 USDC from Wallet A to Wallet B

Now that Wallet A is funded, let’s send 1 USDC from Wallet A to Wallet B using the SDK.

From your earlier script output, grab:

• Wallet A ID
• Wallet B address

Add them into your .env.

Next, you’ll add the USDC token ID, but first create a transfer script called transfer.ts.

This script will:

• initialize the SDK
• fetch Wallet A’s token balances
• print the token balances, including the USDC token ID

Run the script, copy the USDC token ID, and paste it into your .env.

Now complete the transfer logic in transfer.ts.

This will:

• submit a transaction from Wallet A to Wallet B
• poll for transaction status until it confirms
• print the final on-chain transaction hash

Run the script again. You’ll see live status logs in the terminal. Once confirmed, copy the transaction hash and paste it into Sepolia Etherscan.

You should see a completed ERC-20 transfer event showing 1 USDC sent from Wallet A to Wallet B—executed entirely from your backend using the Circle Developer-Controlled Wallet SDK.

---

Recap

And there it is: a complete USDC transfer live on Ethereum Sepolia.

Here’s what we covered:

• set up a Node.js project and installed the SDK
• generated and registered your entity secret
• created a wallet set and two smart contract wallets
• funded Wallet A with Sepolia ETH and USDC via the Circle faucet
• sent 1 USDC from Wallet A to Wallet B using the SDK, with MPC signing handled securely behind the scenes

Whether you’re building payouts, treasury automation, or financial infrastructure, Developer-Controlled Wallets give you full backend control and a production-ready foundation to build with USDC at scale.

Ready to go deeper? Check out the rest of the Stablecoin one hundred one series to learn how stablecoins like USDC are shaping the future of digital finance.