# Aixpa — all pages for AI assistants

> One hub that connects websites to crypto payments, payouts, a PTC offerwall, an ad network and Web3 sign-in through a single API.

Every Markdown page of https://aixpa.store, one after another; each starts with its "Source:" line. Numbers as of 2026-10-12T14:35:54Z (UTC); current values: https://api.aixpa.store/v1/facts

Source: https://aixpa.store/docs/agents

[Home](https://aixpa.store/) › AI agents

Developers

# Aixpa for AI agents

Everything public on Aixpa can be read by an agent without a key: Markdown pages, the facts as JSON, an OpenAPI description and a read-only MCP endpoint.

- [llms.txt](https://aixpa.store/llms.txt) — what is where, with the current fees
- [llms-full.txt](https://aixpa.store/llms-full.txt) — every guide page in one Markdown file
- [openapi.json](https://aixpa.store/openapi.json) — the public read-only API
- `https://api.aixpa.store/mcp` — the MCP endpoint (POST)

## Read the pages as Markdown

Every guide page has a Markdown copy at its own address plus `.md`, for example [/integration.md](https://aixpa.store/integration.md), and [/index.md](https://aixpa.store/index.md) for the home page. The page address itself answers in Markdown when the request asks for it:

```
curl -H 'Accept: text/markdown' https://aixpa.store/integration
```

That answer is never stored by a cache (`Cache-Control: no-store`, `Vary: Accept`); each `.md` file names its page in a canonical `Link` header.

## Numbers as JSON

Fees, revenue shares, minimums, payout limits, the module list and network totals: [/v1/facts](https://api.aixpa.store/v1/facts). Component health: [/v1/status](https://api.aixpa.store/v1/status). Crypto prices: [/v1/rates](https://api.aixpa.store/v1/rates). All three are described in [openapi.json](https://aixpa.store/openapi.json), need no key and answer any origin.

Network totals count every project together and show only from a floor up, so no single site can be read out of them.

## Connect over MCP

A remote MCP server, read-only and without a key, at `https://api.aixpa.store/mcp` (Streamable HTTP: one JSON answer per request, no session). In Claude Code:

```
claude mcp add --transport http aixpa https://api.aixpa.store/mcp
```

Other clients take the same address as a remote HTTP server. The tools:

- `get_status` — Live health of every hub component (API, database, payment gateways, payout rails, rates, each sign-in method). Same data as GET https://api.aixpa.store/v1/status.
- `get_rates` — Crypto/USD prices the hub serves to connected sites, refreshed every few minutes; stale: true marks an old price. Same data as GET https://api.aixpa.store/v1/rates.
- `get_facts` — The public numbers of the hub: payment fee, revenue shares, minimums, payout limits and methods, the module registry and network totals (shown only from a floor up). Same data as GET https://api.aixpa.store/v1/facts.
- `list_payment_methods` — Every coin and network a project can be paid in: its lane (invoice, permanent address or FaucetPay), the live minimum in USD and whether it can be paid right now.
- `search_docs` — Search the hub documentation (home, features, pricing, integration guide, agent guide) and get the matching passages with their page URLs.

Every tool only reads. Up to 60 requests a minute per IP address; above that the endpoint answers 429.

Without a client, one request is enough:

```
curl -s https://api.aixpa.store/mcp -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_facts","arguments":{"section":"payments"}}}'
```

## Server manifest

The entry for MCP registries (`server.json`), kept with the source as `ops/claude/mcp/server.json`:

```
{
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "name": "store.aixpa/hub",
  "title": "Aixpa hub (read-only)",
  "description": "Read-only Aixpa hub data: status, crypto rates, fees and limits, payment methods, docs search.",
  "version": "1.0.0",
  "websiteUrl": "https://aixpa.store/docs/agents",
  "remotes": [
    {
      "type": "streamable-http",
      "url": "https://api.aixpa.store/mcp"
    }
  ]
}
```

## Rules for agents

- Read anything public: pages, Markdown, JSON and the MCP tools. The facts are rebuilt at most hourly, so polling every few minutes is plenty.
- Nothing here signs up, signs in or moves money. Automated sign-up, sign-in or use of the dashboard, checkout and admin screens breaks the [Terms](https://aixpa.store/terms), as [robots.txt](https://aixpa.store/robots.txt) says.
- Too many requests get a `429` answer: wait a minute, then try again.
- To act for a person (create a project, read its stats), that person creates a personal API token in the dashboard; a token can never withdraw. See the [integration guide](https://aixpa.store/integration).

## Copy-ready prompt

For an assistant that should answer questions about Aixpa:

```
Use the Aixpa hub as a read-only source. Start with https://aixpa.store/llms.txt.
For current fees and limits call https://api.aixpa.store/v1/facts (or the MCP tool
get_facts at https://api.aixpa.store/mcp). Quote numbers from those answers, not from
memory, and say when they were generated. Never sign up, sign in or submit forms.
```

Source: https://aixpa.store/integration

[Home](https://aixpa.store/) › Integration guide

Developers

# Integration guide

One project per website. Aixpa handles sign-in, payments, payouts and ads; your site keeps its own users and data.

New here? See [what each module does](https://aixpa.store/features) and [what it costs](https://aixpa.store/pricing); the steps below open one at a time.

## 1. Create a project

Dashboard → **Projects** → Connect a new website . You get:

| Key | Where it goes |
| --- | --- |
| `pk_…` project ID | Browser code (public) |
| `sk_…` secret key | Server `.env` only. Signs webhooks and login tokens. Rotate it from the dashboard if it leaks. |

Automating it? Create a personal API token (dashboard → API tokens) and call `POST /api/projects` with `Authorization: Bearer axp_…`. Tokens can create and configure projects but can never withdraw.

## 2. Login (wallet, Google, email)

One button, every method: the Aixpa sign-in window offers Google, a 6-digit email code, browser wallets (MetaMask, Trust, OKX, Phantom, Solflare) and WalletConnect. Google and email run on Aixpa's own accounts — your site needs no Google Cloud project, no mail server and no extra keys.

```
<script src="https://aixpa.store/sdk/v1.js"></script>
<script>
  Aixpa.init({ project: 'pk_…' });
  const { token } = await Aixpa.login();   // popup: Google, email code, wallets
  await fetch('/api/login', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ token }) });
  // Mobile wallets may come back with #aixpa_token=…  →  Aixpa.redirectToken()
</script>
```

The token is a JWT (HS256, key = your secret key, valid 1 hour) and is only ever delivered to the origin of your registered site URL. Verify it on your server, then create your own session:

```
import { Aixpa } from './aixpa-node.mjs';          // https://aixpa.store/sdk/aixpa-node.mjs — one file, no deps
const aixpa = new Aixpa(process.env.AIXPA_SECRET_KEY);
const claims = aixpa.verifyLogin(token);           // null if forged/expired
// claims.sub = "evm:0xabc…" | "solana:…" | "google:…" | "email:you@x.com"  → unique key of the user in YOUR database
// claims.address = wallet address or email (for display), claims.method = "wallet" | "google" | "email"
```

No Node? Call `POST https://api.aixpa.store/v1/auth/introspect` with the secret key and `{ "token": "…" }` → `{ "active": true, "sub": … }`.

## 3. Top-ups (crypto invoices)

```
// server
const { invoice } = await aixpa.createInvoice({ amountUsd: 10, payCurrency: 'USDT-TRC20', orderId: `topup:${userId}:${uniqueId}` });
// browser
await Aixpa.pay(invoice.payUrl);   // hosted checkout: QR, address, countdown, live status
```

Coins: `USDT-TRC20 USDT-BEP20 BTC ETH LTC DOGE TRX BNB SOL`, or `FAUCETPAY` (payer pays from their FaucetPay balance in any coin, ideal for small top-ups). Minimum $1 (some coins higher). `orderId` is unique per project. Fee: 0.5% of the amount received.

Two clocks: `expiresAt` is the 60-minute price quote, `payableUntil` how long the address stays this invoice's (up to 90 days for BTC / LTC). A transaction reported before `expiresAt` is credited at the quoted price (up to the quoted amount) when it confirms; anything later — also a payment that replaced it — at the price when it arrives. An invoice made without the new fields (no `account`, the payer pays the fee) reads one clock, as before: unpaid past `expiresAt` it answers `status: "expired"` — a late payment still turns it `paid` and sends `invoice.paid`. With `account` or `feePaidBy: "merchant"` it stays `pending` until `payableUntil`.

## 4. Webhooks — the only place to credit

Set the webhook URL in project settings (public https). Every event is a `POST` with JSON `{ event, createdAt, data }` and header `x-aixpa-signature: t=<ms>,v1=<hex HMAC-SHA256(secret, t + "." + rawBody)>`. Answer 2xx; failures retry for about 2 days. Events can arrive twice — credit with a unique reference.

```
const event = aixpa.verifyWebhook(rawBody, req.headers['x-aixpa-signature']);
if (!event) return res.status(401).end();
if (event.event === 'invoice.paid') credit(userFrom(event.data.orderId), event.data.netUsd, `invoice:${event.data.id}`);
```

| Event | Data |
| --- | --- |
| `invoice.paid` | id, orderId, amountUsd, receivedUsd, feeUsd, netUsd, payCurrency |
| `invoice.held` / `deposit.held` | id, account, reasonCode (e.g. shared_address, partial_payment, other_coin, unknown_amount, extra_payment), reason; orderId on an invoice, invoiceId + orderId on a deposit that belongs to one — checked by hand, nothing to credit yet |
| `deposit.paid` / `deposit.rejected` | id (`dep_…` a payment to a permanent address; `fp_…` / `rev_…` a second or other-coin payment on an invoice, released by hand), account, invoiceId + orderId when it belongs to an invoice, receivedUsd, feeUsd, netUsd, paidAt — credit `netUsd` once per id; `rejected`: the held payment was closed, nothing to credit |
| `payout.sent` / `payout.failed` / `payout.review` | id, reference, coin, address, amountUsd, amountCrypto, txHash, status |
| `ptc.completed` | transactionId, userId, reward, currencyName, payoutUsd |
| `offer.completed` / `offer.reversed` | transactionId, network, userId, reward, payoutUsd |

**A webhook that never reached you** (your server was down longer than the retries, or answered 2xx without crediting): read what was paid and credit it with the same unique reference — a payment credited before is skipped by your own ledger. Run it once a day, or after an outage.

```
// every paid invoice after your stored cursor, oldest paid first — each row is what its invoice.paid carried
for (;;) {
  const { invoices, next } = await aixpa.paidInvoices({ after: cursor, limit: 200 });
  for (const inv of invoices) {
    if (inv.netUsd !== undefined) credit(userFrom(inv.orderId), inv.netUsd, `invoice:${inv.id}`);
    cursor = inv.id;   // store it: the next run starts here
  }
  if (!next) break;
}
```

`GET /v1/invoices?status=paid&after=<invoice id>&limit=<1–200>` → `{ invoices, next }`; `after` must be a paid invoice of your project (else `400 invalid_cursor`); an invoice paid in the last second shows on the next read. One invoice: `aixpa.getInvoice(id)` — once `status` is `"paid"` it carries the same `receivedUsd`, `feeUsd`, `netUsd` as its webhook (an invoice paid before these were stored has none: skip it, as the loop does). Everything sent as `deposit.paid` is listed the same way: `aixpa.deposits({ status: 'paid', after, limit })` → `{ deposits, next }`, ids `dep_…`, `fp_…`, `rev_…`, each row equal to its webhook.

## 5. Payouts to your users

```
await aixpa.payout({ amountUsd: 1.5, coin: 'LTC', address: 'ltc1…', reference: `wd:${withdrawalId}` });   // on-chain
await aixpa.payout({ amountUsd: 0.2, coin: 'DOGE', address: 'player@mail.com', reference: `wd:${id}` });     // FaucetPay
```

Paid from the project balance. Reusing a `reference` returns the first payout, so retries never pay twice. A LTC address goes on-chain; a FaucetPay email or FaucetPay-linked address (BTC ETH LTC DOGE BCH DASH DGB TRX BNB SOL XRP ADA TON USDT ZEC XLM) is paid instantly through FaucetPay — ideal for small faucet withdrawals. Force a rail with `method: 'onchain' \| 'faucetpay'`. Status of every rail: [aixpa.store/status](https://aixpa.store/status).

## 6. Ads and rewards

Create a zone in project settings, then `Aixpa.ad(document.getElementById('slot'), 'zn_…')`. Offerwall and PTC rewards reach your webhook as `ptc.completed` / `offer.completed` with the `userId` you passed (letters, digits, `_ . @ -`).

## 6b. Offerwalls and surveys (one embed)

Every offerwall and survey network connected to Aixpa (BitcoTasks, CPX Research, BitLabs, TimeWall, Monlix…) plus Aixpa PTC, in one page. Put it where a signed-in user earns, with **your own user id** (the same id your webhook credits):

```
<iframe src="https://aixpa.store/earn?p=pk_…&u=USER_ID" style="width:100%;height:900px;border:0"></iframe>
```

Completed offers reach your webhook as `offer.completed` (and `offer.reversed` on a chargeback) with `userId` = the `u` you passed, the reward in your currency and your USD share. No account at any network is needed: Aixpa holds them all.

## 7. Ads: new tab, banner and text

One line anywhere in your pages. On a visitor's click (any link, button or text), the next promoted page opens in a **new tab of the same browser and takes focus**; the page they clicked still works normally. Campaigns rotate per visitor (A → B → C → A). Create a **New tab** zone in project settings to earn your share.

```
<script async src="https://aixpa.store/static/js/main.js" data-id="zn_…"></script>
```

| Attribute | Meaning |
| --- | --- |
| `data-id` | Your New tab zone. Omit to show only the network's house ads (no revenue share). |
| `data-interval` | Minimum seconds between two tabs for one visitor. Default 30; `0` = every click. |

### Banner + text slots (same script)

With a **Banner + text** zone, put `<div data-slot></div>` anywhere: header, sidebar, between posts, mobile footer. Each slot measures its own width and shows a banner that fits (728x90, 468x60, 300x250, 320x50) or a text ad when no banner fits. Slots on one page get different ads, and ads rotate evenly on every view.

```
<script async src="https://aixpa.store/static/js/main.js" data-id="zn_…"></script>
<div data-slot></div>                     <!-- any width -->
<div data-slot data-height="60"></div>     <!-- limit the height (e.g. mobile bar) -->
```

`data-refresh="60"` on the script tag rotates slots every 60 s while the page is visible (minimum 15). Slots added later (infinite scroll, SPA pages) are filled automatically.

Popup blockers allow it because the ad link is fetched before the click and opened synchronously inside the visitor's own click. File and API paths look like ordinary site assets, so generic filter rules do not match them; a visitor's ad blocker can still block any third-party script. Try it live on [/tab-test](https://aixpa.store/tab-test).

## Starter project

A complete example (Node, SQLite, no npm): wallet login, top-up, webhook crediting with an idempotent coin ledger. In the Aixpa repo: `node ops/dev/new-project.mjs --name "My Game" --site https://mygame.com --dir ../mygame` creates the project and the folder with `.env` already filled.

## Server API reference

| Call | Auth |
| --- | --- |
| `POST /v1/invoices` · `GET /v1/invoices/:id` | secret key |
| `GET /v1/invoices?status=paid` · `GET /v1/deposits?status=paid` | secret key |
| `GET /v1/balance` | secret key |
| `POST /v1/payouts` · `GET /v1/payouts/:id` | secret key |
| `POST /v1/auth/introspect` | secret key |
| `GET/POST /api/projects` · `GET/POST /api/projects/:id` · `POST /api/projects/:id/zones` | session or API token |

Base URL `https://api.aixpa.store`. Errors: `{ "ok": false, "error": "code" }` with a matching HTTP status.

Source: https://aixpa.store/features

[Home](https://aixpa.store/) › Features

Features

# Everything your sites need to earn and get paid

Each module plugs into the same project keys and ledger. The badge on each one shows whether it is live, in beta or planned.

[Modules](https://aixpa.store/features#modules) [Platform](https://aixpa.store/features#platform) [Roadmap](https://aixpa.store/features#roadmap)

## Payment gateway Live

Your site asks Aixpa for an invoice or a permanent deposit address; Aixpa talks to the gateway, shows the checkout and confirms the payment with a signed webhook. Gateways only ever see Aixpa.

- Invoices and permanent addresses in 12 coins
- Several gateways behind one API, with automatic fallback
- Hosted checkout: QR code, address and live status
- One payment, one ledger entry: credits are idempotent
- Webhook retries with manual resend
- Payouts to FaucetPay or on-chain, from $0.05

## PTC & offerwall Live

Embed one Aixpa offerwall page. Users view ads and finish offers; Aixpa verifies each completion and sends a signed postback with the reward in your site's currency.

- PTC ads with a view timer
- Partner offerwalls and surveys in one embed
- Reward rate set per project, in your own currency
- You keep 70% of every offer payout
- Reversed offers reach your webhook too

## Ad network Live

Publishers place one script and mark the slots; advertisers fund campaigns from their Aixpa balance. Every campaign is reviewed before it runs.

- Banner zones in standard sizes (728×90, 300×250, 468×60, 320×50)
- Text ads where no banner fits
- New-tab ads, opened by a visitor's own click
- A daily cap on every campaign
- Invalid-traffic checks on every impression and click
- Publishers keep 70% of the ad spend on their zones

## Web3 auth Live

Sign-in as a hosted service: drop in the script, receive a signed token and keep your own user table. The same project keys unlock payments and ads.

- MetaMask, Trust, OKX, Rabby, Coinbase (EIP-4361)
- Phantom, Solflare, Backpack (Sign-In with Solana)
- Mobile wallets through WalletConnect
- Google, Telegram, or an email and password
- Tokens are verified on your server with your secret key

## AI-agent access Beta

Agents read Aixpa without a key and work with it through personal API tokens. Keys that let an agent act within a scope are planned.

- llms.txt, Markdown copies of the guide pages and an OpenAPI description of the public reads
- A read-only MCP endpoint: status, rates, fees, payment methods and a docs search
- Personal API tokens create and configure projects and read stats
- A token can never withdraw or act as an admin, and can be revoked from the dashboard

[How an agent connects](https://aixpa.store/docs/agents)

## Swap aggregator Planned

Aixpa will compare quotes from several exchange partners and route each swap to the best rate. Coins will go straight from the partner to the user's wallet; Aixpa will never hold them.

- Quotes from several exchange partners
- Fixed and floating rates
- Swap page, embeddable widget and project API

Ready to wire one in? [Integration guide](https://aixpa.store/integration) · [Pricing](https://aixpa.store/pricing) · [Create an account](https://aixpa.store/signup)

## Built into every module

### Project API Live

One project ID and secret per website, a ledger behind every balance and signed webhooks with retries.

### Shield Live

Shared fraud signals: a device, wallet or email blocked on one connected site is flagged on the others; IP checks for VPN and proxies.

### Live rates Live

Crypto prices from several public sources with automatic fallback, served to every site.

## Planned next

Not built yet: nothing in this list can be used today, and no date is promised.

### Balance transfers Planned

Free transfers between Aixpa accounts, so earnings, ad budgets and payouts share one balance.

### Buy crypto with card Planned

An on-ramp aggregator that compares card providers for the best price.

### Telegram bot & Mini App Planned

Pay, earn from PTC tasks and check balances without leaving Telegram.

### Payment links Planned

Payment links, donation pages and invoices for sellers without a website.

### Network referrals Planned

Invite publishers, advertisers and merchants and receive a share of the fees they pay.

### Mass payouts Planned

Pay many users in one call to FaucetPay or on-chain wallets.

### Token gating Planned

Restrict access to holders of a token or NFT, built into Web3 auth.

Source: https://aixpa.store/pricing

[Home](https://aixpa.store/) › Pricing

Pricing

# No monthly fee. Pay only when you earn.

Every number here is read from the live API. Launch pricing may change before general availability.

[Merchant](https://aixpa.store/pricing#merchant) [Publisher](https://aixpa.store/pricing#publisher) [Advertiser](https://aixpa.store/pricing#advertiser)

## Merchant

Accept crypto on your sites.

0.5% per payment

On a 100 USD invoice the gateway passes on in full, you receive **$99.50** and the hub fee is **$0.50**.

- Invoices, permanent addresses and payouts
- Signed webhooks with retries
- Gateway and network fees passed on at cost

- **Smallest payment** $1
- **Smallest FaucetPay payment** $0.10
- **Coins accepted** 12
- **Payout, smallest to largest** $0.05 – $50
- **Payouts a day, per balance** $200
- **Payout fee** $0

[Start as merchant](https://aixpa.store/signup?type=merchant)

## Publisher

Earn from PTC, offers and ad zones.

70% revenue share

When advertisers spend 100 USD on your zones, you receive **$70**. An offer that pays 100 USD pays you **$70**.

- PTC and partner offerwalls in one embed
- Banner, text and new-tab ad zones
- Withdraw to FaucetPay or on-chain

- **Your share of ad spend** 70%
- **Your share of offerwall payouts** 70%
- **Payout, smallest to largest** $0.05 – $50
- **Payouts a day, per balance** $200
- **Payout fee** $0

[Start as publisher](https://aixpa.store/signup?type=publisher)

## Advertiser

Reach crypto-native audiences.

$1 minimum deposit

A 100 USD top-up is **$100** of campaign budget: up to **100,000** PTC views or **1,000,000** banner views at the lowest bids.

- PTC, banner, text and new-tab campaigns
- A daily cap on every campaign
- Campaigns are reviewed before they run

- **Aixpa fee on a top-up** 0%
- **PTC, lowest bid per view** $0.001
- **PTC view time, seconds** 5 – 60
- **Banner, lowest bid per 1,000 views** $0.10
- **Text ad, lowest bid per 1,000 views** $0.05
- **New tab, lowest bid per 1,000 tabs** $0.50

[Start as advertiser](https://aixpa.store/signup?type=advertiser)

How a payment, a payout or an ad is wired: [integration guide](https://aixpa.store/integration). What is running right now: [live status](https://aixpa.store/status).

Source: https://aixpa.store/

One hub · every website

# Crypto payments, PTC and ads behind a single API.

Connect your sites once: accept crypto, pay users, run PTC tasks and serve ads from one dashboard.

[Create free account](https://aixpa.store/signup) [See pricing](https://aixpa.store/pricing)

[Shops](https://aixpa.store/#merchants) [Sites](https://aixpa.store/#publishers) [Ads](https://aixpa.store/#advertisers) [Devs](https://aixpa.store/#developers)

## For merchants

0.5% per payment

- No monthly fee
- Invoices and fixed addresses in 12 coins, confirmed by signed webhook
- Payouts to FaucetPay or on-chain from $0.05

[Start as merchant](https://aixpa.store/signup?type=merchant) [Fee example](https://aixpa.store/pricing#merchant)

## For publishers

70% revenue share

- PTC and offerwalls in one embed; you keep 70% of offer payouts
- Banner, text and new-tab ad zones
- Payout fee $0, to FaucetPay or on-chain

[Start as publisher](https://aixpa.store/signup?type=publisher) [Share example](https://aixpa.store/pricing#publisher)

## For advertisers

0% top-up fee

- PTC from $0.001 a view, banners from $0.10 per 1,000
- Top up from $1 for PTC, banner, text and new-tab campaigns
- A daily cap and a review on every campaign

[Start as advertiser](https://aixpa.store/signup?type=advertiser) [What a budget buys](https://aixpa.store/pricing#advertiser)

## For developers

21 payment methods

- One API, one project ID and secret per site
- Signed webhooks with retries, a ledger per project
- API tokens for scripts and agents, which can never withdraw

[Integration guide](https://aixpa.store/integration) [All features](https://aixpa.store/features)

Live today

## One integration, every module

7 modules live on one set of keys and webhooks. [Live status](https://aixpa.store/status) · [Planned next](https://aixpa.store/features#roadmap)

### Payment gateway Live

Crypto invoices and permanent deposit addresses, confirmed to your site by signed webhook, plus payouts to FaucetPay or on-chain.

[More about Payment gateway](https://aixpa.store/features#payments)

### PTC & offerwall Live

Paid-to-click ads and partner offerwalls your users complete for rewards, each completion sent to your site as a signed postback.

[More about PTC & offerwall](https://aixpa.store/features#ptc)

### Ad network Live

Banner, text and new-tab ad zones for publishers; self-serve campaigns with budgets and review for advertisers.

[More about Ad network](https://aixpa.store/features#ads)

### Web3 auth Live

Sign-in for any site: Ethereum and Solana wallets, WalletConnect, Google, Telegram or a password. One script, signed tokens.

[More about Web3 auth](https://aixpa.store/features#auth)

### AI-agent access Beta

Agents read the hub through llms.txt, Markdown pages, OpenAPI and a read-only MCP endpoint, and use personal API tokens that never move money; keys scoped to act are next.

[More about AI-agent access](https://aixpa.store/features#ai-agents)

### Swap aggregator Planned

Crypto swaps routed to the best quote of several exchange partners, non-custodial.

[More about Swap aggregator](https://aixpa.store/features#swap)

### Network totals, all projects

- **Projects live (shown from 10)** —
- **Invoices settled, 30 days (from 100)** —
- **Payouts sent, 30 days (from 100)** —
- **Ad impressions today (from 10,000)** —

A total below its floor shows a dash, so no single site can be read out of it.