> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.ordergroove.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.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://docs.ordergroove.com/reference/rest-rpc-api/items/create

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: ordergroove-restrpc
  version: 1.0.0
paths:
  /items/create/:
    post:
      operationId: create
      summary: Create
      description: >-
        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.
      tags:
        - items
      parameters:
        - name: x-api-key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: '200'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Items_create_Response_200'
        '400':
          description: '400'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Items-createRequestBadRequestError'
        '403':
          description: '403'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Items-createRequestForbiddenError'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                merchant_id:
                  type: string
                  description: Merchant ID
                customer_id:
                  type: string
                  description: Customer ID
                shipping_id:
                  type: string
                  description: Shipping address record ID
                payment_id:
                  type: string
                  description: Payment record ID
                offer_id:
                  type: string
                  description: Offer ID
                product_id:
                  type: string
                  description: Product ID
                place_date:
                  type: string
                  description: Date for order placement, should be in MM/DD/YYYY format
                quantity:
                  type: integer
                  description: Number of items
                contexts:
                  $ref: >-
                    #/components/schemas/ItemsCreatePostRequestBodyContentApplicationJsonSchemaContexts
                  description: Items contexts as key:value
              required:
                - merchant_id
                - customer_id
                - shipping_id
                - payment_id
                - offer_id
                - product_id
                - place_date
                - quantity
servers:
  - url: https://restapi.ordergroove.com
    description: https://restapi.ordergroove.com
components:
  schemas:
    ItemsCreatePostRequestBodyContentApplicationJsonSchemaContexts:
      type: object
      properties: {}
      description: Items contexts as key:value
      title: ItemsCreatePostRequestBodyContentApplicationJsonSchemaContexts
    ItemsCreatePostResponsesContentApplicationJsonSchemaComponentsItems:
      type: object
      properties: {}
      title: ItemsCreatePostResponsesContentApplicationJsonSchemaComponentsItems
    Items_create_Response_200:
      type: object
      properties:
        order:
          type: string
        offer:
          description: Any type
        subscription:
          type: string
        product:
          type: string
        components:
          type: array
          items:
            $ref: >-
              #/components/schemas/ItemsCreatePostResponsesContentApplicationJsonSchemaComponentsItems
        subscription_component:
          type: string
        quantity:
          type: integer
          default: 0
        public_id:
          type: string
        product_attribute:
          description: Any type
        price:
          type: string
        extra_cost:
          type: string
        total_price:
          type: string
        one_time:
          type: boolean
          default: true
        order_updated:
          type: string
        frozen:
          type: boolean
          default: true
        first_placed:
          description: Any type
      title: Items_create_Response_200
    Items-createRequestBadRequestError:
      type: object
      properties:
        '[field_name]':
          type: string
      title: Items-createRequestBadRequestError
    Items-createRequestForbiddenError:
      type: object
      properties:
        detail:
          type: string
      title: Items-createRequestForbiddenError
  securitySchemes:
    x-api-key:
      type: apiKey
      in: header
      name: x-api-key

```

## 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
{}
```

**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()
```