> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.ordergroove.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.ordergroove.com/_mcp/server.

# Create

POST https://restapi.ordergroove.com/items/create/
Content-Type: application/json

This endpoint locates an existing order using the specified place date, shipping, payment and customer parameters, adding an additional item to that order.  If no order exists with these parameters, it will create a new order and add an item for that order.

Reference: https://developer.ordergroove.com/reference/rest-rpc-api/items/create

## Authentication

- `x-api-key` header (required) — Application API Scope — server-to-server, sent in the `x-api-key` header. See [Authentication](/api-reference/authentication).
- `authorization` header (required) — Storefront API Scope — client-side, scoped to one customer, sent as a signature in the `authorization` header. See [Authentication](/api-reference/authentication).

## Request

### Body (application/json)

This endpoint expects an object.

- `merchant_id` (string, required) — Merchant ID
- `customer_id` (string, required) — Customer ID
- `shipping_id` (string, required) — Shipping address record ID
- `payment_id` (string, required) — Payment record ID
- `offer_id` (string, required) — Offer ID
- `product_id` (string, required) — Product ID
- `place_date` (string, required) — Date for order placement, should be in MM/DD/YYYY format
- `quantity` (integer, required) — Number of items
- `contexts` (ItemsCreatePostRequestBodyContentApplicationJsonSchemaContexts, optional) — Items contexts as key:value

## Response

### 200

200

- `order` (string, optional)
- `offer` (string, optional, nullable)
- `subscription` (string, optional)
- `product` (string, optional)
- `components` (list of ItemsCreatePostResponsesContentApplicationJsonSchemaComponentsItems, optional)
- `subscription_component` (string, optional)
- `quantity` (integer, optional, default: 0)
- `public_id` (string, optional)
- `product_attribute` (any, optional)
- `price` (string, optional)
- `extra_cost` (string, optional)
- `total_price` (string, optional)
- `one_time` (boolean, optional, default: true)
- `order_updated` (string, optional)
- `frozen` (boolean, optional, default: true)
- `first_placed` (any, optional)

## Errors

### 400 Bad Request Error

400

- `[field_name]` (string, optional)

### 403 Forbidden Error

403

- `detail` (string, optional)

## Types

### ItemsCreatePostRequestBodyContentApplicationJsonSchemaContexts

Items contexts as key:value

### ItemsCreatePostResponsesContentApplicationJsonSchemaComponentsItems

## Examples

**Request**

```json
{
  "merchant_id": "string",
  "customer_id": "string",
  "shipping_id": "string",
  "payment_id": "string",
  "offer_id": "string",
  "product_id": "string",
  "place_date": "string",
  "quantity": 1
}
```

**Response**

```json
{
  "order": "45c27952cd9211e8855abc764e106cf4",
  "offer": null,
  "subscription": "6199282ccd8f11e88267bc764e106cf4",
  "product": "0070067698",
  "components": [],
  "subscription_component": "85eae83c245111eeb185acde48001122",
  "quantity": 1,
  "public_id": "45c39ceccd9211e8855abc764e106cf4",
  "price": "79.99",
  "extra_cost": "0.00",
  "total_price": "35.99",
  "one_time": false,
  "order_updated": "2025-01-31 00:00:00",
  "frozen": false
}
```

**SDK Code**

```python Result
import requests

url = "https://restapi.ordergroove.com/items/create/"

payload = {
    "merchant_id": "string",
    "customer_id": "string",
    "shipping_id": "string",
    "payment_id": "string",
    "offer_id": "string",
    "product_id": "string",
    "place_date": "string",
    "quantity": 1
}
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Result
const url = 'https://restapi.ordergroove.com/items/create/';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"merchant_id":"string","customer_id":"string","shipping_id":"string","payment_id":"string","offer_id":"string","product_id":"string","place_date":"string","quantity":1}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Result
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://restapi.ordergroove.com/items/create/"

	payload := strings.NewReader("{\n  \"merchant_id\": \"string\",\n  \"customer_id\": \"string\",\n  \"shipping_id\": \"string\",\n  \"payment_id\": \"string\",\n  \"offer_id\": \"string\",\n  \"product_id\": \"string\",\n  \"place_date\": \"string\",\n  \"quantity\": 1\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Result
require 'uri'
require 'net/http'

url = URI("https://restapi.ordergroove.com/items/create/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"merchant_id\": \"string\",\n  \"customer_id\": \"string\",\n  \"shipping_id\": \"string\",\n  \"payment_id\": \"string\",\n  \"offer_id\": \"string\",\n  \"product_id\": \"string\",\n  \"place_date\": \"string\",\n  \"quantity\": 1\n}"

response = http.request(request)
puts response.read_body
```

```java Result
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://restapi.ordergroove.com/items/create/")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"merchant_id\": \"string\",\n  \"customer_id\": \"string\",\n  \"shipping_id\": \"string\",\n  \"payment_id\": \"string\",\n  \"offer_id\": \"string\",\n  \"product_id\": \"string\",\n  \"place_date\": \"string\",\n  \"quantity\": 1\n}")
  .asString();
```

```php Result
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://restapi.ordergroove.com/items/create/', [
  'body' => '{
  "merchant_id": "string",
  "customer_id": "string",
  "shipping_id": "string",
  "payment_id": "string",
  "offer_id": "string",
  "product_id": "string",
  "place_date": "string",
  "quantity": 1
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp Result
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/items/create/");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"merchant_id\": \"string\",\n  \"customer_id\": \"string\",\n  \"shipping_id\": \"string\",\n  \"payment_id\": \"string\",\n  \"offer_id\": \"string\",\n  \"product_id\": \"string\",\n  \"place_date\": \"string\",\n  \"quantity\": 1\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Result
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "merchant_id": "string",
  "customer_id": "string",
  "shipping_id": "string",
  "payment_id": "string",
  "offer_id": "string",
  "product_id": "string",
  "place_date": "string",
  "quantity": 1
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/items/create/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```