# MCP quickstart

Source: https://portal.printedsimply.com/docs/quickstarts/mcp

Quickstart · Claude, Cursor or ChatGPT

Order from a chat with your assistant. No code at all.

The agent makes the artwork, a person approves it, and we make the thing. Custom stickers, decals, magnets and posters, printed in one US plant. A run of one is an order: every product's minimum_quantity is 1. A test key runs the same order through a $0 sandbox from placed to delivered. Every status change arrives as a signed webhook, on a test order as on a live one. Each artwork file is checked at the size it prints before a live order is charged. An order line can declare how its artwork was made and who approved it, and the order and its webhooks carry that declaration.

About 3 minutes $0 sandbox key Ends with a sandbox order on its way

## Step 1: Create a sandbox key

In the dashboard, open API keys and create a key in Test mode. It starts with ps_test_ — test keys are free, never charge a card, and never reach a print facility. You can create one before adding a payment method.

[Create a test key](https://portal.printedsimply.com/dashboard/api-keys?env=test)

key:

```
ps_test_YOUR_KEY
```

A live key (ps_live_) takes the same requests. A real order also needs a card on file and your own artwork: Going live, at the end of this page, has the four changes.

## Step 2: Point your client at the MCP endpoint

The server is remote and always on — nothing to install or run locally. Add it to your MCP client config and restart the client.

config:

```json
{
  "mcpServers": {
    "printedsimply": {
      "url": "https://portal.printedsimply.com/api/mcp",
      "headers": { "x-api-key": "ps_test_YOUR_KEY" }
    }
  }
}
```

URL only:

```
https://portal.printedsimply.com/api/mcp?x-api-key=ps_test_YOUR_KEY
```

Use the URL-only form for clients whose connector UI has a URL field but no header field. Sandbox test keys only — never put a live key in a URL. No key yet? https://portal.printedsimply.com/api/mcp?profile=visitor needs none: it searches the catalog, prices an order, checks artwork and places a $0 sandbox order on a demo account, then hands you a link to finish on the dashboard.

## Step 3: See what it can do

The server carries 28 tools, the ones for ordering what PrintedSimply makes: find a product, price it, check the artwork, place the order and follow it to the door. Your client lists them as soon as it connects.

tools:

```
search_catalog         Search the catalog
get_product            Get a product
get_product_options    List custom-size options
recommend_products     Recommend products
estimate_shipping      Estimate shipping
get_calendar           Get the plant calendar
quote_order            Quote an order
estimate_pricing       Estimate a price
create_mockup          Render a product mockup
validate_artwork       Check a print file
create_order           Place an order
reorder                Place an order again
get_order_status       Get an order's status
track_order            Track a shipment
list_orders            List orders
cancel_order           Cancel an order
get_order_events       Get an order's events
update_order_address   Change an order's address
update_order_shipping  Change an order's shipping
add_order_item         Add an item to an order
update_order_item      Change an item's quantity
cancel_order_item      Cancel one order item
whoami                 Check this key
check_setup            Check account setup
list_assets            List uploaded files
get_asset              Get an uploaded file
upload_asset           Upload a file
delete_asset           Delete an uploaded file
```

Cancelling or changing an order before production is among these tools; get_order_status's actions says what an order still takes. The rest of your account (webhooks) is on the dashboard and the REST API, with the same key.

## Step 4: Ask for the order in plain English

The assistant finds the SKU, prices it, checks the artwork and calls create_order for you. Ask it to run whoami first if you want it to see the key's mode, scopes and spend caps before it spends anything.

prompt:

```
Find a die-cut sticker in the catalog, quote 100 of them shipped
standard to Jane Doe, 123 Main St, Austin TX 78701, US, and place the order.
```

## Step 5: Skip the wait

The assistant reads each step with track_order as the sandbox moves the order on. To move it now, simulate it over REST with the same key and the order_id the assistant was given.

shell:

```bash
curl -X POST "https://portal.printedsimply.com/api/v1/order/test_ord_YOUR_ORDER_ID/simulate" \
  -H "x-api-key: ps_test_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"target_state": "shipped"}'
```

Left alone, a sandbox order moves on by itself: a scheduled job takes it to in_production, shipped and delivered over about five minutes, firing the same signed webhooks at each step. simulate does not wait for that schedule. It takes in_production, shipped, delivered, cancelled or issue_flagged, and only on a test key. An order the schedule has already delivered answers 400 already_terminal; to rehearse the step again, place a new order with a new reference and Idempotency-Key (the sample uses one value for both; the same key replays the delivered order, and the same reference under a new key is refused 409 duplicate_reference).

## Step 6: Open the tracking link and watch it deliver

create_order returns the tracking link straight into the conversation. Open it, then ask the assistant to check again: it calls track_order and reads you the new status, until it is delivered.

Sandbox orders run the real lifecycle on a compressed clock: created → in_production → shipped → delivered, firing genuinely HMAC-signed webhooks at every transition through the same delivery pipeline live orders use. Leave the tracking page open.

## Going live

The sandbox order above never charges, prints or ships. A real one takes four changes.

### Add a card in Billing

A live order is charged to the card on file when it is placed. Without one, POST /v1/order answers 402 no_payment_method and nothing is placed.

[Open Billing](https://portal.printedsimply.com/dashboard/billing)

### Create a live key

On the API keys page, create a key in Live mode. It starts with ps_live_ and is shown in full once, so store it where your server reads secrets, never in a browser.

[Create a live key](https://portal.printedsimply.com/dashboard/api-keys?env=live)

### Send the same request with your own artwork

Swap in the live key, your customer's address and your artwork: an https link to the file (PNG, PDF or SVG), or the id POST /v1/assets returns, as print_file. A live order's artwork is checked before anything is charged: a line with no artwork answers 422 artwork_required, and a file that cannot be printed answers 422 artwork_not_printable.

### Subscribe a live-mode webhook

A subscription in test mode receives sandbox events only. For real orders, subscribe your endpoint in live mode (or all) on the Webhooks page or with POST /v1/webhooks, and verify X-PS-Signature-V2 on every delivery.

[Open Webhooks](https://portal.printedsimply.com/dashboard/webhooks)

## Scopes this page needs

A key created without an explicit scope list gets all of them. If you scope the key down, grant at least these:

- `orders:read`
- `orders:write`
- `products:read`
- `pricing:read`
- `assets:read`
- `assets:write`
- `artwork:write`
- `mockups:write`

## Order placed. What's next?

- [Subscribe to webhooks](https://portal.printedsimply.com/docs/webhooks)

  Get order.shipped pushed to you instead of polling — signed, replayable, deduped.

- [Understand the limits](https://portal.printedsimply.com/docs/rate-limits)

  Per-plan rate and daily limits, the headers we return, and how to back off honestly.

- [Browse the API reference](https://portal.printedsimply.com/docs/api-reference)

  Every v1 endpoint, with its required scopes and response shape.

- [Try another quickstart](https://portal.printedsimply.com/docs/quickstarts)

  The same order in curl, TypeScript, Python or PHP, or from your framework.
