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

# YC Startup School Hackathon

<div className="event-hero not-prose">
  <img src="https://mintcdn.com/dynamic-docs-testing/MgxeUAI_lFfs97KT/assets/images/events/dynamic-yc-hackathon-2026-banner.png?fit=max&auto=format&n=MgxeUAI_lFfs97KT&q=85&s=4e22df7bd508f4654e8833fd4d771d1d" alt="Dynamic × YC Startup School Hackathon" className="event-hero-banner" width="1024" height="341" data-path="assets/images/events/dynamic-yc-hackathon-2026-banner.png" />

  <div className="event-hero-meta">
    <span className="event-tag">📅 Friday, July 24, 2026</span>
    <span className="event-tag">📍 San Francisco</span>
    <span className="event-tag">🏆 \$1,000 prize</span>
  </div>
</div>

## What is Dynamic?

Dynamic is wallet infrastructure: one SDK that combines user login, embedded wallets, key management, signing, and stablecoin payments. Instead of stitching together an auth provider, wallet connectors, and a signing stack yourself, you drop in Dynamic and get all of it.

* **Login & onboarding** — email, social, or an existing wallet. Users don't need to understand crypto to sign in.
* **Embedded wallets** — non-custodial wallets created for users automatically, secured with MPC. No seed phrase to hand over.
* **Signing & payments** — sub-second signing, plus stablecoin payments and money movement, backed by Fireblocks security.
* **Any chain, any wallet** — embedded wallets, 800+ external wallets, and cross-chain flows in one place.

For this hackathon that means the hard parts — auth, wallets, signing, and paying — are already handled, so you spend your six hours on your idea.

```mermaid theme={"system"}
flowchart LR
  A["Authentication"] --> D
  B["Wallet connectors"] --> D
  C["Key & wallet management"] --> D
  E["Maintain integrations"] --> D
  F["User management"] --> D
  G["Fraud & bot protection"] --> D
  D(["Integrate Dynamic"]) --> Z["🚀 Build your product"]
  style D fill:#4779ff,stroke:#4779ff,color:#fff
```

**TL;DR — integrate Dynamic, skip the rest, and get straight to building.**

## Ship in 3 steps 💫

Skip the docs. Install the Dynamic MCP, let your agent handle the plumbing, and put your critical thinking where it counts.

<Steps>
  <Step title="Get an account">
    Create an environment in the [Dynamic dashboard](https://app.dynamic.xyz/). Grab your **environment ID**. You'll need it to initialize the SDK.
  </Step>

  <Step title="Install the MCP">
    The Dynamic docs MCP is a server that gives your AI agent live access to our entire documentation (every guide, reference, and code example) so it builds against accurate, up-to-date docs.

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

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

      <Tab title="Codex">
        ```bash theme={"system"}
        codex mcp add dynamic --url https://www.dynamic.xyz/docs/mcp
        ```
      </Tab>

      <Tab title="Other">
        If your editor or agent supports remote HTTP MCP, add a server that points at `https://www.dynamic.xyz/docs/mcp`. The exact steps depend on the product; use its MCP documentation for URL-based or HTTP transport setup.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Ask your agent">
    With the MCP installed, your agent can pull from the docs and start implementing. Copy the starter prompt below to kick things off.
  </Step>
</Steps>

<Tip>
  **Not sure where to start?** After installing the MCP, paste this prompt into your agent and fill in the blanks:

  ```text theme={"system"}
  I'm at the Dynamic × YC Startup School Hackathon (one-day, 6-hour build) and I may
  be new to crypto. Use the Dynamic docs MCP to look up anything you need. Explain
  each step as you go, and ask me questions if my idea is unclear.

  My idea: [what you're building].
  My stack: [framework/language, e.g. React, Next.js, Node].

  Pick the path that fits my idea:
  - Wallets & money movement: use Dynamic for login and an embedded wallet so my
    users can send, receive, and pay. Follow the quickstart for my stack. If I'm on
    React, use the JavaScript SDK with its React hooks (there is no separate React
    SDK) and follow the React quickstart:
    https://www.dynamic.xyz/docs/javascript/reference/react-quickstart
  - Agent wallets: give an agent its own Dynamic wallet to hold funds and sign on its
    own. First ask me how the agent should handle the wallet (who owns it and how it
    signs in), or help me figure out which path best fits my proposed use case. Then
    pick the matching pattern from the comparison table:
    https://www.dynamic.xyz/docs/overview/agents/overview#choose-a-pattern

  Start from working code — either follow the quickstart implementation in the docs,
  or clone the example / starter repo that best matches my idea and adapt it:
  - https://github.com/dynamic-labs-oss/examples/tree/main/examples
  - https://github.com/dynamic-labs-oss/react-via-js-example-app
  - https://github.com/matthew1809/dynamic-agent-payments-starter
  Keep the first version simple: a working demo I can run locally.
  ```
</Tip>

<Tip>
  **More context for your agent:** every docs page has a **Copy page** button (top right). Use it to grab an LLM-optimized version and paste it into your agent.
</Tip>

### New to crypto? Your first transaction 🌱

Prefer to wire it up by hand? Two steps to your first onchain transaction — no seed phrases, no browser extensions. You sign in with email or a social login and Dynamic creates the embedded wallet for you.

<Steps>
  <Step title="Get a login + wallet running">
    Follow the quickstart for your stack — the fastest path to a working sign-in and an embedded wallet:

    * [JavaScript SDK quickstart](/docs/javascript/reference/quickstart)
    * [React quickstart](/docs/javascript/reference/react-quickstart) — JS SDK with React hooks
    * [Node quickstart](/docs/node/quickstart) — server-side
    * [Embedded wallets overview](/docs/overview/wallets/overview) — how the wallet works
  </Step>

  <Step title="Make your first onchain action">
    Send a transaction from the embedded wallet on a testnet. Grab free test tokens from a faucet first (see below), then sign and send. That's your first onchain transaction!
  </Step>
</Steps>

<Note icon="flask">
  **Testnet resources:** build and demo on **Base Sepolia** so there's no real money at risk. Enable it in the dashboard under [Chains & Networks](https://app.dynamic.xyz/dashboard/chains-and-networks), then grab free test funds:

  * [Circle faucet](https://faucet.circle.com/) — testnet USDC on Base Sepolia
  * [Base Sepolia faucets](https://docs.base.org/base-chain/network-information/network-faucets) — testnet ETH for gas
</Note>

## Prize track 🏆

<Card title="Best Project with Dynamic" icon="trophy">
  **Prize: \$1,000.** One track, wide open. Build the best project that uses Dynamic.
</Card>

**Judging criteria**

* **Working demo**
* **Creative use of Dynamic**. Wallets, money movement, or agent wallets.
* **Technical execution**. Clean integration.
* **Would a real user use this?**

## Feature showcase: Agent wallets 🤖

Agent wallets let an AI agent hold funds and sign transactions on its own, with no human approving each action. The agent signs in as a Dynamic user (with a user JWT), so every wallet it creates or uses belongs to that user.

It's one of three wallet patterns Dynamic offers for agents:

* **Agent wallets** — a server-side agent operates a Dynamic user's embedded wallet, signing in with a user JWT. This showcase focuses here.
* **Delegated access** — the end user keeps their wallet and grants the agent limited, revocable signing rights.
* **Server wallets** — backend-owned, signed with your API token. No user involved.

See the [Agents Overview](/docs/overview/agents/overview#choose-a-pattern) pattern table to find which wallet pattern serves your project best.

The fastest start is the **[dynamic-agent-payments-starter](https://github.com/matthew1809/dynamic-agent-payments-starter)** — a Node + TypeScript project that gives an AI agent a wallet and lets it pay for [x402](https://www.x402.org/)-gated APIs autonomously (USDC on Base Sepolia by default). It shows two of the patterns side by side, so you can see the difference:

* **Two wallet routes** — developer-managed **server wallets** (your platform keeps custody) and agent self-identification (**agent wallets**, where each agent signs in as its own Dynamic user).
* **A web dashboard and CLI** — create agents, manage wallets, check live USDC balances, and run payments.
* **A REST API** with agent-management endpoints and flat-file wallet storage to build on.

```bash theme={"system"}
git clone https://github.com/matthew1809/dynamic-agent-payments-starter.git
cd dynamic-agent-payments-starter
npm install
cp .env.example .env   # add your DYNAMIC_ENVIRONMENT_ID and tokens
npm run ui             # web dashboard at localhost:3000
```

New to how agent wallets authenticate and sign? Read the [Agent wallets overview](/docs/node/agents/overview) and the [example usage](/docs/node/agents/example-usage) scripts first.

## Resources 📚

### Open-source examples

Clone, run, and remix these end-to-end projects. Each wires up Dynamic in a real framework, so you can skip the boilerplate and start from working code.

<CardGroup cols={2}>
  <Card title="Agent payments starter" icon="rocket" href="https://github.com/matthew1809/dynamic-agent-payments-starter">
    The event starter — an AI agent with its own Dynamic wallet paying for x402-gated APIs. The primary clone target for the agent path.
  </Card>

  <Card title="React via JS SDK" icon="react" href="https://github.com/dynamic-labs-oss/react-via-js-example-app">
    A React app on the Dynamic JavaScript SDK with its React hooks — the recommended setup for wallet/auth builds in React.
  </Card>

  <Card title="Node — server wallets" icon="node" href="https://github.com/dynamic-labs-oss/examples/tree/main/examples/nodejs-server-wallets">
    Backend-owned wallets signed with your API token — the *server wallets* pattern, not agent wallets. See how they differ in the [Agents overview](/docs/overview/agents/overview).
  </Card>

  <Card title="More examples" icon="github" href="https://github.com/dynamic-labs-oss/examples">
    The full example set — Node and Python server wallets, embedded wallets, and more to remix.
  </Card>
</CardGroup>

**⭐ Star the GitHub repos so they're easy to find again later.**

### Demos

Live demo apps spanning embedded wallets, trading, yield, crypto payments, and global payouts — all built on the Dynamic SDK.

Try the live demo apps at [https://www.dynamic.dev/](https://www.dynamic.dev/).

### Reference docs

* [Embedded wallets](/docs/overview/wallets/overview) — how users get a non-custodial wallet on sign-in.
* [JavaScript SDK quickstart](/docs/javascript/reference/quickstart) — fastest path to a working login and embedded wallet.
* [React quickstart](/docs/javascript/reference/react-quickstart) — same, using the JS SDK with React hooks.
* [Agent wallets](/docs/node/agents/overview) — let a server-side agent operate its own Dynamic wallet as a user.
* [Agent wallets: example usage](/docs/node/agents/example-usage) — complete runnable scripts for each sign-in path.
* [Flow](/docs/overview/fireblocks-flow) — move money across chains: accept any token, settle in one. Works best on mainnet (testnet liquidity is thin); limited function on Base Sepolia + a few EVM testnets.

## FAQ ❓

<AccordionGroup>
  <Accordion title="Do I need crypto experience?">
    No. Dynamic handles login, wallets, and signing for you. Users sign in with email or a social login and get an embedded wallet automatically — no seed phrases, no browser extension. About half the room is new to crypto; the beginner path above is built for you.
  </Accordion>

  <Accordion title="Testnet or real funds?">
    For a 6-hour hack, build and demo on **testnet** — no real money at risk. We recommend **Base Sepolia**: get testnet USDC from the [Circle faucet](https://faucet.circle.com/) and gas ETH from a [Base Sepolia faucet](https://docs.base.org/base-chain/network-information/network-faucets).
  </Accordion>

  <Accordion title="What chains can I use?">
    Dynamic supports EVM chains, Solana, and more (agent wallets support EVM, Solana, Bitcoin, and TON). For a 6-hour build we recommend **Base** — it's fast, cheap, and the most documented chain for x402. Use **Base Sepolia** for testing.
  </Accordion>

  <Accordion title="Who has custody of the wallet?">
    Embedded wallets are **non-custodial**: the user owns the wallet through their own MPC key share, and Dynamic never holds the full key. Agent wallets are still user-owned — the agent authenticates **as the user** (with a user JWT) and signs on their behalf, so every wallet it creates or signs with belongs to that user.
  </Accordion>

  <Accordion title="What's an agent wallet in one sentence?">
    An agent wallet is a Dynamic embedded wallet that a server-side agent operates as a real user — it authenticates with a user JWT and can create wallets and sign on its own, no human approval per action.
  </Accordion>
</AccordionGroup>

## Project Inspo 💡

We highly encourage you to bring your own ideas. The best projects come from problems you've lived. But if you need a starting point, here are a few to spark something.

**Wallets & money movement**

| Idea                    | What you'd build                                                                                                                                                                                                                                                                                                                                                                                                 |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Split the bill          | Friends chip in for a shared expense and settle instantly in stablecoins. Or everyone stakes a set amount up front and the pot pays out later. Each person gets a wallet just by signing in.                                                                                                                                                                                                                     |
| Creator tipping         | Fans tip a creator straight to their embedded wallet, no app-store cut and no bank account required. Similar vibe: the [donate.gg](https://www.donate.gg/) donation platform.                                                                                                                                                                                                                                    |
| Send money home         | Cross-border payout where the recipient claims funds with just an email and gets a wallet automatically. [See an example](https://x.com/Stable/status/2077348728424505617).                                                                                                                                                                                                                                      |
| Recurring subscriptions | Let users subscribe and pay on a schedule in stablecoins, then manage, renew, and cancel from their wallet. Build it with [Fireblocks Flow](/docs/overview/fireblocks-flow) or Solana [subscriptions & allowances](https://solana.com/news/subscriptions-and-allowances) ([overview](https://solana.com/docs/payments/subscriptions/overview)); see our [demo](https://x.com/dynamic_xyz/status/2061864011256549387). |
| Token management        | Hold, send, and swap tokens across chains from one embedded wallet.                                                                                                                                                                                                                                                                                                                                              |
| Pay with Crypto         | Add a "Pay with Crypto" option next to credit cards at checkout, a widget that settles in stablecoins.                                                                                                                                                                                                                                                                                                           |

**Agent wallets**

| Idea                     | What you'd build                                                                                                        |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| Self-funding agent       | An agent with its own wallet that pays for the APIs, data, or compute it needs to finish a task.                        |
| Pay-per-stream media     | A music or media player where an agent pays per stream or per download, settling in stablecoins.                        |
| Subscription manager     | An agent that runs a subscription end to end: pays each cycle, monitors usage, and cancels or downgrades to save money. |
| Autonomous trading agent | An agent that runs a strategy like DCA or rebalancing, signing and transacting from its own wallet.                     |
| Budget-capped allowance  | Give an agent a spending limit and let it operate freely under the cap, with a hard stop when it's spent.               |

Want to see what others have shipped? Browse [hackathon projects built with Dynamic](https://ethglobal.com/showcase?events=newyork2026\&partners=dynamic) on the ETHGlobal showcase.

## Follow us on X

<CardGroup cols={3}>
  <Card title="Dynamic" icon="x-twitter" href="https://x.com/dynamic_xyz">
    @dynamic\_xyz
  </Card>

  <Card title="Fireblocks HQ" icon="x-twitter" href="https://x.com/FireblocksHQ">
    @FireblocksHQ
  </Card>

  <Card title="Kim" icon="x-twitter" href="https://x.com/kimcodeashian">
    @kimcodeashian
  </Card>

  <Card title="Joanna" icon="x-twitter" href="https://x.com/joannatran_">
    @joannatran\_
  </Card>

  <Card title="Matt Foyle" icon="x-twitter" href="https://x.com/MatthewFoyle">
    @MatthewFoyle
  </Card>
</CardGroup>

See you there!