Using Circle Developer Controlled Wallets to Send and Manage USDC

Circle Developer Controlled Wallets: Setup and USDC Transfer Guide

Introduction to Developer Controlled Wallets

Tired of juggling keys and wallets just to move a stablecoin? Here's how to create, fund, and send USDC entirely from your back end using Circle Developer Controlled Wallets. Hi. I'm Elton, and I work on the developer relations team at Circle. Welcome back to Stablecoin 101, 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. If you haven't checked the video out, you can find a link in the description below. In this video, we are going hands-on with developer controlled wallets and walking through how to set up your project, register your entity secret, create and fund wallets, and send a USDC transaction on Ethereum's Sepolia testnet.

Project Setup and SDK Installation

Whether you're building a payout platform, treasury automation, or customizing finance flows, this is the foundation you need to program USDC at scale with full back-end control and multi-party computation (MPC) signing handled securely by Circle.

Let's start by setting up a simple project so that we can interact with Circle Developer Controlled Wallets from our back end. First, create a folder. I'll call mine circle-dcw-demo, but feel free to use any name you like. Then, initialize a new Node.js project. Now, we install the packages we need. This includes the:

• Circle Developer Controlled Wallet 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 us to use modern import statements in our scripts.

Generating API Keys and Entity Secrets

Now we are 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 your secure sign-in credential. To generate your API key, head over to 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.

Next, we'll generate an entity secret. The entity secret is a cryptographic key that you use to authenticate your API requests. It stays with you just like your own private sign-in credential. Let's create a script and call it generate-secret.ts, then run it using npx tsx. This will output a brand new entity secret; copy it and add it to your .env file.

Registering the Entity Secret

Last but not least, we register the entity's secret with Circle and download a recovery file. This 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 make sure you store it somewhere safe. Create a new script and call it register-secret.ts, then run the script. If everything worked, you'll see a recovery file saved in your project directory. Hold on to it in a secure place.

Initializing the SDK and Creating Wallets

At this point, you have set up your environment file, generated your entity secret, registered it with Circle, and saved the recovery file. Now we're ready to move on to initialize the SDK to start working with wallets. First, create a new script file and call it wallet-demo.ts. In this file, we import the SDK and initialize the developer controlled wallets client using the credentials from your .env file. Then run it. If you see "SDK initialized," you're all set.

Now let's create a wallet set. You can think of it 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 wallet-demo.ts.

Now let's create two smart contract wallets on the Ethereum Sepolia testnet, both fully managed from your back end. Sepolia is a test environment on the Ethereum blockchain—a sandbox for developers. You can use it to create and interact with wallets just like you would on the main net without spending real ETH. Run the script once more. You'll now have Wallet A and Wallet B, smart contract wallets that are fully programmable and entirely controlled from your back end.

Funding Wallets via Circle Faucet

Before we test out transactions, you need to fund Wallet A with some Sepolia ETH and USDC. Go back to the Circle Developer Console, and in the left-hand sidebar, open the faucet. In the Wallet ID field, paste the ID for Wallet A that we logged in the terminal. Then select Sepolia ETH and USDC. Then click Send Tokens. After a few seconds, you'll see testnet ETH and USDC deposited into Wallet A.

To confirm the balance, you can use the Circle Console, or head to sepolia.etherscan.io and paste in the Wallet A address. You'll see both ETH and USDC balances and the most recent transfer listed under Token Transfers.

Executing a USDC Transfer

Now that we have a funded wallet, let's send one USDC from Wallet A to Wallet B using the SDK. Grab the Wallet A ID and Wallet B address and add them into your .env file. We also need the USDC token ID. Create a new file called transfer.ts. This script will initialize the SDK, fetch Wallet A's token balances, and help you pull the USDC token ID. Copy the token ID shown for USDC and paste it into your .env file.

Now, complete the transfer logic in transfer.ts. This will submit a transaction from Wallet A to Wallet B, poll the transaction status until it's confirmed, and print the final on-chain hash so that you can verify it on Etherscan. Run the script once more. You'll see a live status log in the terminal, and once the transfer is confirmed, it will print the on-chain transaction hash.

Copy the transaction hash and head over to Etherscan. Paste the hash in the search bar and you'll see a completed ERC-20 transfer event showing one USDC sent from Wallet A to Wallet B executed fully from your back end using the Circle SDK.

Conclusion and Recap

And there it is, a complete USDC transfer live on Ethereum Sepolia. Let's quickly recap:

1. We set up the project and installed the SDK.
2. Generated and registered your entity's secret.
3. Created a wallet set and spun up two smart contract wallets.
4. Funded Wallet A with testnet ETH and USDC using the Circle faucet.
5. Finally, sent one USDC from Wallet A to Wallet B using Circle's SDK with secure signing handled behind the scenes by MPC.

Whether you're building payouts, treasury automation, or financial infrastructure, developer controlled wallets give you full control and a production-ready foundation to build with USDC at scale. Ready to go deeper? Check out the rest of the Stablecoin 101 series to learn more. See you in the next video.