> Agent-readable docs index: /llms.txt. Download /docs.zip to grep all markdown files locally.

---
title: "Backend ordering"
description: "This guide provides step-by-step instructions for submitting an order via Rye using your backend."
---

#### At a glance

* All the operations from this guide can be executed on the backend and do not require client-side code.

* You will capture funds from the shopper using whatever payment gateway you prefer.

* After capturing funds from the shopper, you will place the order with Rye using the [`submitCart`](/api-reference/submitcart) mutation.

<Note>
  For a live production example of creating an order using the Rye SDK in TypeScript, check out our [Order from Amazon in TypeScript](/order-from-amazon-typescript) guide.
</Note>

## Step-by-step guide

### 1. Get a cart ready

First, we need to prepare a cart for checkout. We have a tutorial on this [here](/get-started/cart-management/create-a-cart). You will need to create the cart, attach the buyer's identity, and optionally select shipping options for the store(s) you are purchasing from. Once you have a cart ready for checkout, you can return here to follow the remaining steps.

### 2. Capture payment from your customer

Once you have a cart prepared for checkout, you can query its `cost` field to determine how much you need to charge the shopper for the order.

When placing the order, it is up to you to charge the shopper. You may use any payment gateway you prefer, although our recommendation is generally [Stripe](https://stripe.com) as it is relatively easy to get set up with them. Once you have charged the shopper, you will have collected funds for the order, but the Rye cart will still be pending checkout.

### 3. Submit the cart

Once you have collected the payment from the shopper, we'll use the [`submitCart`](/api-reference/submitcart) mutation to submit the cart.

For our mutation, we'll request some new fields `status` and `orderId` from the `stores` field. These fields will be used to track the status of the order, so be sure to take a look at the `status` and copy the `orderId` somewhere for later. We'll also request `errors` back on the store level just in case we have an issue with placing the order.

<Tabs items={["Request", "Response"]}>
  <Tab title="Request">
    ```graphql
    mutation SubmitCart {
      submitCart(input: {
        id: "YOUR_CART_ID_HERE"
        selectedShippingOptions: [
          {
            store: "rye-staging-test-store.myshopify.com"
            shippingId: "YOUR_CHOSEN_SHIPPING_ID_HERE"
          }
        ]
      }) {
        cart {
          id
          stores {
            status
            # Note: This `orderId` field is important!
            orderId
            store {
              ... on ShopifyStore {
                store
                cartLines {
                  quantity
                  variant {
                    id
                  }
                }
              }
            }
            errors {
              code
              message
            }
          }
        }
        errors {
          code
          message
        }
      }
    }

    ```
  </Tab>

  <Tab title="Response">
    ```json
    {
      "data": {
        "submitCart": {
          "cart": {
            "id": "YOUR_CART_ID_HERE",
            "stores": [
              {
                "status": "COMPLETED",
                "orderId": "SOME_ORDER_ID",
                "store": {
                  "store": "rye-staging-test-store.myshopify.com",
                  "cartLines": [
                    {
                      "quantity": 1,
                      "variant": {
                        "id": "42707875856575"
                      }
                    }
                  ]
                },
                "errors": []
              }
            ]
          },
          "errors": []
        }
      }
    }
    ```
  </Tab>
</Tabs>

Congrats! You've successfully submitted an order via Rye! The `orderId` you copied from the response represents a Rye [Order](/api-reference/order).

### 4. Check order status

Once we've successfully created an order, we can keep track of its status using two main methods:

1. Receiving [webhook updates](/webhooks) from Rye (recommended)

2. Polling using the [`orderByID`](/api-reference/orderbyid) query

While listening for webhooks is recommended in production, for the purposes of this guide we can use polling. See the [`OrderStatus` enum](/api-reference/orderstatus) for all possible statuses.

<Tabs items={["Request", "Response"]}>
  <Tab title="Request">
    ```graphql
    query OrderById {
      orderByID(id: "YOUR_ORDER_ID_HERE") {
        id
        status
        events {
          id
          createdAt
          ... on OrderFailedOrderEvent {
            reason
          }
        }
        requiredActions {
          ... on CompletePaymentChallenge {
            redirectURL
          }
        }
      }
    }
    ```
  </Tab>

  <Tab title="Response">
    ```json
    {
      "data": {
        "orderByID": {
          "id": "YOUR_ORDER_ID_HERE",
          "status": "SOME_STATUS",
          "events": [
            {
              "id": "9e3d69ce-5781-4148-ac23-343f5b0c74b8",
              "createdAt": "2024-01-18T22:00:32.716Z"
            },
            {
              "id": "27bfec9f-6e1f-447b-9942-f02cb8537f99",
              "createdAt": "2024-01-18T22:00:35.340Z"
            }
          ],
          "requiredActions": []
        }
      }
    }
    ```
  </Tab>
</Tabs>

## Next steps

Congrats on making it this far! Here are some next steps you could take:

* [Learn about Rye webhooks](/webhooks) and build out a [webhook integration](/test-webhooks-integration)

* Learn more about Rye by visiting our [FAQs page](/faq)


---

*Powered by [holocron.so](https://holocron.so)*