# Accept service bookings and payments from agents

Help AI agents find, book, and pay for your services.

Your customers can use AI agents to book travel, reserve tables, and schedule appointments. If your business offers these services, you can provide structured booking and payment flows that agents can use instead of navigating your website.

Use this guide if you:

- Operate a marketplace, platform, or booking system for bookable services.
- Have APIs or a Model Context Protocol (MCP) server that agents can use to search availability and manage bookings.
- Want to allow agents to complete payments using customer-approved payment credentials.

You don’t need to replace your current booking or payment architecture. You can let agents book and pay programmatically by giving them access to your APIs or equivalent MCP tools.

Stripe doesn’t require a specific endpoint structure, tool naming convention, or payload schema. The examples in this guide show common patterns, not a required Stripe schema.

A user asks an agent to book a service, the agent searches and books through the business's booking API or MCP server, and pays with an agent wallet credential. (See full diagram at https://docs.stripe.com/agentic-commerce/for-sellers/agent-ready)

```text
[User] -- Request a service --> [Agent]
[Agent] -- Search availability --> [Business]
[Business] -- Return availability --> [Agent]
[Agent] -- Return availability --> [User]
[User] -- Confirm booking --> [Agent]
[Agent] -- Initiate checkout --> [Business]
[Business] -- Spend request --> [Stripe]
[User] -- Approve in Link --> [Stripe]
[Stripe] -- Spend approval --> [Agent]
[Agent] -- Share Link credential --> [Business]
[Business] -- Charge Link credential --> [Stripe]
[Stripe] -- Confirm payment --> [Business]
[Business] -- Confirm booking --> [Agent]
[Agent] -- Booking confirmed --> [User]
```

## Enable programmatic booking

Provide structured interfaces that let agents complete bookings without navigating your website. Support each stage of the booking lifecycle with operations that let agents:

- Search for services and availability.
- Create a booking.
- Retrieve or modify a booking.
- Cancel a booking.

You can expose these operations through a booking API or an MCP server.

#### Booking API

You can make your booking API publicly available or limit access to selected agent partners. Provide a separate endpoint for each booking operation:

| Example endpoint | Purpose |
| --- | --- |
| `GET /availability` | Return open slots for a service, date, and party size or quantity. |
| `POST /bookings` | Create a booking for a specific slot and return a booking ID and confirmation details. |
| `GET /bookings/{id}` | Return the current status and details of a booking. |
| `PATCH /bookings/{id}` | Change the slot, date, or party size of an existing booking. |
| `DELETE /bookings/{id}` | Cancel an existing booking. |

When an individual asks an agent to check availability, the agent sends the requested service, date, and quantity to your API:

```json
GET api.seller.com/availability?service_id=haircut&date=2026-09-10&party_size=1
```

Return available booking options in a structured format. The agent can present these options to the customer and use the selected option in the next booking request.

```json
{
  "service_id": "haircut",
  "date": "2026-09-10",
  "slots": [
    {
      "slot_id": "slot_1400",
      "start_time": "2026-09-10T14:00:00Z",
      "end_time": "2026-09-10T14:30:00Z",
      "price": {
        "amount": 4500,
        "currency": "usd"
      }
    },
    {
      "slot_id": "slot_1530",
      "start_time": "2026-09-10T15:30:00Z",
      "end_time": "2026-09-10T16:00:00Z",
      "price": {
        "amount": 4500,
        "currency": "usd"
      }
    }
  ]
}
```

Use stable identifiers throughout the booking lifecycle so the agent can select an option and later retrieve, modify, or cancel the resulting booking.

Return structured errors that tell the agent what happened and whether it can retry. For example, if a selected time is no longer available, return a `409` conflict response with an error code the agent can interpret:

```json
{
  "error": {
    "code": "slot_unavailable",
    "message": "The selected time is no longer available."
  }
}
```

This lets the agent search for another time instead of failing the booking without a recovery path.

#### MCP server

You can expose the same booking operations as tools through an MCP server. This gives agents a structured alternative to navigating your website or calling an undocumented API. Use a separate tool for each operation:

| Example tool | Purpose |
| --- | --- |
| `search_availability` | Return open slots for a service, date, and party size or quantity. |
| `create_booking` | Create a booking for a specific slot and return a booking ID and confirmation details. |
| `modify_booking` | Change the slot, date, or party size of an existing booking. |
| `cancel_booking` | Cancel an existing booking. |

For example, you might create a `search_availability` tool that accepts the following inputs. You can choose the tool name, inputs, and response format.

```typescript
server.registerTool(
  'search_availability',
  {
    description: 'Search available slots for a service on a given date.',
    inputSchema: {
      serviceId: z.string(),
      date: z.string(),
      partySize: z.number().int().positive().optional(),
    },
  },
  async ({ serviceId, date, partySize }) => {
    const slots = await searchAvailability({ serviceId, date, partySize })
    return { content: [{ type: 'text', text: JSON.stringify(slots) }] }
  },
)
```

Use clear names and descriptions to help agents determine when to call each tool. Return structured results with stable identifiers that agents can pass between tools.

For example, `search_availability` returns a `slot_id` that the agent passes to `create_booking`. The agent then passes the returned `booking_id` to tools that retrieve, update, or cancel the booking.

## Accept programmatic payments

Agents use the [Link agent wallet](https://docs.stripe.com/agentic-commerce/link-cli.md) to retrieve secure payment credentials from a customer’s Link wallet and complete purchases on the customer’s behalf without accessing or storing their card details. Use [Shared Payment Tokens](https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens.md) (SPTs) to accept these agent-initiated payments. SPTs give you scoped access to the customer’s payment method for the purchase.

### Accept an SPT

Accept an SPT either through your booking API or MCP server. You can add the SPT to the request that creates or confirms a booking. For example:

```json
POST api.seller.com/bookings/slot_1400/confirm
{
  "payment_data": {
    "token": "spt_123",
    "provider": "stripe"
  }
}
```

If you expose booking tools through an MCP server, accept the SPT as an input to the tool that creates or confirms the booking.

### Process the payment

How you process the resolved payment credentials depends on your payments setup:

**If you process payments with Stripe:** SPTs work natively with your existing Stripe payment integration, including Stripe Connect integrations. You can continue using your existing risk controls, fraud detection, reporting, and operational workflows. See [Shared Payment Tokens](https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens.md) for current SPT supportability.

**If you process payments with another processor:** Contact your Stripe representative to discuss availability and integration options requirements.

## See also

- [Shared Payment Tokens](https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens.md)