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

# Quick Start

> From sign-up to accepting AI agent payments — create your account, set up a project, get your keys, then pick the integration path that fits your stack.

Getting Prism running is the same three steps for everyone — **create an account, set up a project, and generate an API key**. What comes after depends on what you're building. If you run one of the e-commerce platforms we have plugins for, you can be live in minutes with no protocol code. If you're building something custom, the same open APIs get you there.

This guide covers the shared setup, then points you to the right integration path.

## Step 1: Create your District Pass

Your [District Pass](/overview/district-pass) is one account for everything in Finance District — it's how you log in to the Prism Console. Sign up with just an email, no KYC or wallet connection required.

<Steps>
  <Step title="Create your District Pass">
    Visit [apps.fd.xyz](https://apps.fd.xyz/) and sign up with your email — or sign in if you already have an account.
  </Step>

  <Step title="Confirm your email">
    Enter the confirmation code sent to your inbox. Your District Pass is now active.
  </Step>
</Steps>

## Step 2: Set up your project

Log in to the [Prism Console](https://apps.fd.xyz/prism/) with your District Pass. The Console is where you configure payments, monitor transactions, and manage credentials.

<Steps>
  <Step title="Create a project">
    Create a new Project or use the default one. Each Project has its own API keys, payment configuration, and transaction history — use separate Projects for different applications or environments (e.g. test vs. production).
  </Step>

  <Step title="Configure payments">
    Under **Settings → Payments**, set your **merchant wallet** (where settlement funds are received) and choose the tokens and chains you want to accept. You can change these anytime.
  </Step>
</Steps>

<Tip>
  Prefer to manage everything from an AI assistant? The [Prism MCP Server](/prism/integrations/mcp-server) exposes the same setup — projects, tokens, payments — as tools for Claude Desktop, Cursor, and other MCP clients.
</Tip>

## Step 3: Create your API key

In the Console, navigate to **Project Identify Tokens** and click **Create Project Identify Token**. Give it a descriptive name and copy the token — this is the key that links agent payments to your merchant account.

<Warning>
  Keep your Project Identify Token secret. It authenticates via the `X-API-Key` header — never expose it in client-side code, public repositories, or logs. If it's compromised, rotate it in the Console.
</Warning>

That's the account setup done. Everything from here is integration — and how much you build depends on your stack.

## Step 4: Choose your integration path

<CardGroup cols={3}>
  <Card title="E-commerce platform" icon="cart-shopping" href="/prism/platforms">
    Running Saleor, Medusa, Shopware, PrestaShop, or WooCommerce? Install our
    plugin, paste your token — live in minutes, no protocol code.
  </Card>

  <Card title="Custom storefront" icon="puzzle-piece" href="/prism/platforms/custom">
    Headless build or an unsupported platform? Make any store agent-payable with
    the Prism APIs and server-side SDKs.
  </Card>

  <Card title="Monetize an API" icon="code" href="#option-c-monetize-an-api-or-content">
    Charge AI agents per request for an API, endpoint, or piece of content using
    x402 payment middleware.
  </Card>
</CardGroup>

### Option A: E-commerce platform (fastest)

If you already run a storefront on one of the supported platforms below, you don't write any integration code. We maintain **official, open-source extensions** that add agent-commerce endpoints to your store — product discovery, checkout, and on-chain settlement.

| Platform | Install as | Requirements |
| - | - | - |
| **Saleor** | Next.js storefront SDK (npm) | Saleor + a Next.js storefront |
| **Medusa** | Medusa v2 backend plugin (npm) | Medusa v2, Node.js ≥ 20 |
| **Shopware** | Shopware 6.7 plugin (PHP) | Shopware ≥ 6.7.10, PHP ≥ 8.2 |
| **PrestaShop** | PrestaShop modules (PHP) | PrestaShop 1.7.8 / 8.x / 9.x |
| **WooCommerce** | WordPress plugin set (PHP) | WordPress 6.4+, WooCommerce 8.0+ |

The path is the same for every platform: **install the extension → paste your Project Identify Token into its config → go live.** Your store starts advertising a `/.well-known/ucp` profile, and agents can discover your catalog, check out, and pay — settled instantly in stablecoins, with no chargebacks.

<Card title="E-commerce Platforms" icon="store" href="/prism/platforms">
  Pick your platform and follow its install guide.
</Card>

### Option B: Custom storefront

No official plugin for your stack? The extensions above are convenience layers over open protocols — nothing is locked to a specific platform. Implement the same three-step merchant contract directly: advertise a `/.well-known/ucp` profile with the Prism payment handler, call Prism to prepare each checkout, and forward the signed payment credential to settle on-chain.

<Card title="Custom Integrations" icon="puzzle-piece" href="/prism/platforms/custom">
  The merchant integration pattern, server-side SDKs, and the pluggable
  payment-handler interface our official extensions are built on.
</Card>

### Option C: Monetize an API or content

Not selling products — want AI agents to pay per request to access an API, endpoint, or piece of content? Protect a route with x402 payment middleware. When an agent hits it without paying, it gets a `402 Payment Required` response with payment instructions; after paying, the request goes through.

<Steps>
  <Step title="Install the SDK">
    <Tabs>
      <Tab title="TypeScript">
        ```bash theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        npm install @1stdigital/prism-express
        ```
      </Tab>

      <Tab title="Python">
        <Info>
          **Coming soon.** Python SDKs (`prism-flask`, `prism-fastapi`, `prism-django`) are not yet published to PyPI. The install command below shows the planned package.
        </Info>

        ```bash theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        pip install finance-district
        ```
      </Tab>

      <Tab title="Java">
        <Info>
          **Coming soon.** The Java SDK (`prism-sdk`) is not yet published to Maven Central. The dependency below shows the planned coordinates.
        </Info>

        ```xml theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        <dependency>
          <groupId>xyz.financedistrict</groupId>
          <artifactId>prism-sdk</artifactId>
          <version>LATEST</version>
        </dependency>
        ```
      </Tab>
    </Tabs>

    See [SDK Overview](/prism/sdk/overview) for all supported frameworks including NestJS, Next.js, FastAPI, Flask, and Django.
  </Step>

  <Step title="Add payment middleware">
    <Tabs>
      <Tab title="Express.js">
        ```typescript theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        import express from "express";
        import { prismPaymentMiddleware } from "@1stdigital/prism-express";

        const app = express();

        app.use(
          prismPaymentMiddleware(
            {
              identifyToken: process.env.PRISM_IDENTIFY_TOKEN,
              baseUrl: "https://prism-gw.fd.xyz",
            },
            {
              "/api/premium": {
                price: "$0.01",
                description: "Premium API access",
              },
            }
          )
        );

        app.get("/api/premium", (req, res) => {
          res.json({
            message: "Premium content",
            payer: req.payer,  // wallet address that paid
          });
        });

        app.listen(3000, () => console.log("Server running on port 3000"));
        ```
      </Tab>

      <Tab title="FastAPI">
        <Info>
          **Coming soon.** The `prism-fastapi` package is not yet published to PyPI. The code below shows the planned API.
        </Info>

        ```python theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        from fastapi import FastAPI, Depends
        from finance_district import require_payment, PaymentVerified

        app = FastAPI()

        @app.get("/api/premium")
        async def premium_content(
            payment: PaymentVerified = Depends(require_payment(0.01, "USD"))
        ):
            return {"content": "Premium data", "payer": payment.payer}
        ```
      </Tab>

      <Tab title="Flask">
        <Info>
          **Coming soon.** The `prism-flask` package is not yet published to PyPI. The code below shows the planned API.
        </Info>

        ```python theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
        from flask import Flask, jsonify
        from finance_district import require_payment

        app = Flask(__name__)

        @app.route("/api/premium")
        @require_payment(amount=0.01, currency="USD")
        def premium_content():
            return jsonify({"content": "Premium data"})
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Test it">
    Start your server and hit the protected endpoint — you should get a `402 Payment Required` response with x402 payment instructions:

    ```bash theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
    curl http://localhost:3000/api/premium
    ```

    ```json theme={"theme":{"light":"github-light","dark":"one-dark-pro"}}
    {
      "x402Version": 2,
      "error": "Payment required to access this resource",
      "accepts": [
        {
          "scheme": "exact",
          "network": "eip155:84532",
          "amount": "10000",
          "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
          "payTo": "0xYourWallet...",
          "maxTimeoutSeconds": 300,
          "extra": { "name": "USD Coin", "version": "2" }
        }
      ]
    }
    ```

    This confirms the middleware works. Any AI agent with a compatible wallet — including [Agent Wallet](/agent-wallet/overview) — can now pay and access the endpoint automatically.
  </Step>
</Steps>

<Tip>
  To test the full payment flow, use the [Agent Wallet CLI](/agent-wallet/ai-integration/cli) or connect an Agent Wallet via [MCP](/agent-wallet/ai-integration/mcp-server) and ask the agent to access your endpoint.
</Tip>

## Step 5: Go live

Whichever path you took, going to production is the same:

1. Switch your Project to mainnet in the Console settings
2. Generate a mainnet Project Identify Token and update your integration
3. Set your production merchant wallet address
4. Monitor transactions in the [Prism Console](https://apps.fd.xyz/prism/)

<Note>
  You can test with small amounts on production chains — the API and SDKs work identically regardless of transaction size.
</Note>

## What's next?

<CardGroup cols={2}>
  <Card title="E-commerce Platforms" icon="cart-shopping" href="/prism/platforms">
    Plugins for Saleor, Medusa, Shopware, PrestaShop, and WooCommerce
  </Card>

  <Card title="Custom Integrations" icon="puzzle-piece" href="/prism/platforms/custom">
    Make any store agent-payable with the open protocols and APIs
  </Card>

  <Card title="How Prism Works" icon="diagram-project" href="/prism/concepts/how-it-works">
    Two-layer architecture and the transaction lifecycle
  </Card>

  <Card title="Prism Console" icon="sliders" href="/prism/production/console">
    Manage tokens, transactions, analytics, and payment settings
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.