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

# Create Order

> This endpoint creates a new order.

### Body

<ParamField body="id" type="string">
  This is the ID of the order to be created.
</ParamField>

<ParamField body="name" type="string">
  This is the name of the order.
</ParamField>

<ParamField body="number" type="string">
  This is the number of the order.
</ParamField>

<ResponseField name="source" required="true" type="string">
  This is the source of the order.
</ResponseField>

<ParamField body="customerID" type="string">
  This is the ID of the customer who placed the order.
</ParamField>

<ParamField body="items" type="array">
  This is the list of items in the order.
</ParamField>

<ParamField body="totalAmount" type="object">
  The total amount of the order

  <Expandable title="properties">
    <ParamField body="value" type="string" required>
      The numeric amount (e.g., "150.00")
    </ParamField>

    <ParamField body="denom" type="string" required>
      The denomination: "ssusd" (default), "usdc" (legacy), or "usd"
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="paymentStatus" type="string">
  This is the payment status of the order. Options: "unpaid", "pending", "paid", "partially\_paid", "failed"
</ParamField>

<ParamField body="paymentMethod" type="object">
  The preferred payment method for this order.

  <Expandable title="properties">
    <ParamField body="type" type="string">
      Payment method type. Options: "ssusd" (default), "usdc" (legacy), "card", "bank\_transfer"
    </ParamField>

    <ParamField body="wallet_address" type="string">
      Customer's wallet address for stablecoin payments
    </ParamField>

    <ParamField body="chain" type="string">
      Preferred blockchain: "stateset" (default), "base", "solana", "cosmos"
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="shippingStatus" type="string">
  This is the shipping status of the order.
</ParamField>

<ParamField body="metadata" type="object">
  This is additional metadata related to the order.
</ParamField>

### Response

<ResponseField name="success" type="number">
  Indicates whether the call was successful. 1 if successful, 0 if not.
</ResponseField>

<ResponseField name="order" type="object">
  The created order object

  <Expandable title="properties">
    <ResponseField name="id" type="string">
      Unique order identifier
    </ResponseField>

    <ResponseField name="totalAmount" type="object">
      Order total with denomination
    </ResponseField>

    <ResponseField name="paymentMethod" type="object">
      Configured payment method
    </ResponseField>

    <ResponseField name="status" type="string">
      Order status
    </ResponseField>
  </Expandable>
</ResponseField>

### Notes

* Orders are created with `paymentStatus: "unpaid"` by default
* To pay for an order after creation, use the [Pay Order endpoint](/stateset-commerce-api-reference/orders/pay)
* All monetary amounts should be specified in USDC
* StateSet Commerce Network uses native USDC - no bridging required

<RequestExample>
  ```bash cURL theme={null}
  curl --location --request POST 'https://api.stateset.network/v1/order' \
  --header 'Content-Type: application/json' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --data-raw '{
      "name": "Premium Subscription Order",
      "number": "ORD-2024-001",
      "source": "web_checkout",
      "customerID": "cust_123456",
      "items": [
          {
              "product_id": "prod_premium_annual",
              "quantity": 1,
              "price": "150.00",
              "name": "Premium Annual Subscription"
          }
      ],
      "totalAmount": {
          "value": "150.00",
          "denom": "ssusd"
      },
      "paymentStatus": "unpaid",
      "paymentMethod": {
          "type": "ssusd",
          "wallet_address": "stateset1qypqxpq9qcrsszg2pvxq6rs0zqg3yyc5lzv7xu",
          "chain": "stateset"
      }
  }'
  ```

  ```javascript Node.js theme={null}
  const axios = require('axios');

  async function createOrderWithSSUSD(customerData) {
    try {
      const orderData = {
        name: `Order for ${customerData.name}`,
        number: `ORD-${Date.now()}`,
        source: 'api',
        customerID: customerData.id,
        items: customerData.items,
        totalAmount: {
          value: calculateTotal(customerData.items),
          denom: 'ssusd'
        },
        paymentStatus: 'unpaid',
        paymentMethod: {
          type: 'ssusd',
          wallet_address: customerData.wallet_address,
          chain: customerData.preferred_chain || 'stateset'
        }
      };

      const response = await axios.post(
        'https://api.stateset.network/v1/order',
        orderData,
        {
          headers: {
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
          }
        }
      );

      console.log('Order created:', response.data.order);
      return response.data;
    } catch (error) {
      console.error('Failed to create order:', error.response?.data || error.message);
      throw error;
    }
  }

  function calculateTotal(items) {
    return items.reduce((total, item) => {
      return total + (parseFloat(item.price) * item.quantity);
    }, 0).toFixed(2);
  }
  ```

  ```python Python theme={null}
  import requests
  from typing import List, Dict

  def create_order_with_ssusd(customer_data: Dict) -> Dict:
      """Create an order with ssUSD payment method"""
      
      url = "https://api.stateset.network/v1/order"
      
      headers = {
          "Authorization": "Bearer YOUR_API_KEY",
          "Content-Type": "application/json"
      }
      
      # Calculate total
      total = sum(float(item['price']) * item['quantity'] for item in customer_data['items'])
      
      order_data = {
          "name": f"Order for {customer_data['name']}",
          "number": f"ORD-{int(time.time())}",
          "source": "api",
          "customerID": customer_data['id'],
          "items": customer_data['items'],
          "totalAmount": {
              "value": f"{total:.2f}",
              "denom": "ssusd"
          },
          "paymentStatus": "unpaid",
          "paymentMethod": {
              "type": "ssusd",
              "wallet_address": customer_data['wallet_address'],
              "chain": customer_data.get('preferred_chain', 'stateset')
          }
      }
      
      try:
          response = requests.post(url, json=order_data, headers=headers)
          response.raise_for_status()
          
          result = response.json()
          print(f"Order created: {result['order']['id']}")
          return result
          
      except requests.exceptions.RequestException as e:
          print(f"Failed to create order: {e}")
          if hasattr(e, 'response') and e.response:
              print(f"Error details: {e.response.json()}")
          raise

  # Example usage
  customer = {
      "id": "cust_123456",
      "name": "John Doe",
      "wallet_address": "stateset1qypqxpq9qcrsszg2pvxq6rs0zqg3yyc5lzv7xu",
      "preferred_chain": "stateset",
      "items": [
          {
              "product_id": "prod_001",
              "name": "Premium Widget",
              "price": "99.99",
              "quantity": 2
          }
      ]
  }

  order = create_order_with_ssusd(customer)
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "success": 1,
    "order": {
      "id": "order_1a2b3c4d5e6f",
      "name": "Premium Subscription Order",
      "number": "ORD-2024-001",
      "source": "web_checkout",
      "customerID": "cust_123456",
      "items": [
        {
          "product_id": "prod_premium_annual",
          "quantity": 1,
          "price": "150.00",
          "name": "Premium Annual Subscription"
        }
      ],
      "totalAmount": {
        "value": "150.00",
        "denom": "ssusd"
      },
      "paymentStatus": "unpaid",
      "paymentMethod": {
        "type": "ssusd",
        "wallet_address": "stateset1qypqxpq9qcrsszg2pvxq6rs0zqg3yyc5lzv7xu",
        "chain": "stateset"
      },
      "status": "pending",
      "created_at": "2024-01-15T12:00:00Z"
    }
  }
  ```
</ResponseExample>