> 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.

# List price codes

GET https://restapi.ordergroove.com/products/{product_id}/price_codes/

Returns every price code configured for a product, ordered by `price_code`.

A price code lets one product serve a different price to a group of customers. Each price code maps a code to a price, and a product can carry many of them. Ordergroove resolves a code for each order from the customer or from the shipping address, depending on how the merchant's price driver is configured, and charges the price mapped to that code. When the product has no price code matching the resolved value, the product's base `price` applies.

By convention, codes resolved from the customer are prefixed `Cust_` and codes resolved from the shipping address are prefixed `Ship_`, but a code is matched exactly and any string is accepted. These are the same price codes the XML product feed writes, so a catalog can be priced by code through either path.

Price codes are scoped to the merchant that owns the product, so a request for another merchant's product returns `404`, not `403`. Both Application API Scope and Storefront API Scope credentials can read price codes; only Application API Scope can change them.

Reference: https://docs.ordergroove.com/reference/rest-rpc-api/products/product-price-codes-list

## Authentication

- `x-api-key` header (required)

## Request

### Path parameters

- `product_id` (string, required) — Merchant product ID

## Response

### 200

200

- `price_codes` (list of object, required) — Price codes configured for the product, ordered by `price_code`.
  - `price_code` (string, required) — Price code the price is mapped to. Up to 100 characters. Matching is case-insensitive, so `Cust_1` and `cust_1` are the same price code.
  - `price` (string, required, nullable) — Price charged for the product when this price code applies, as a decimal string with two decimal places. `null` on price codes created by a product feed without a price; a price code written through this API always has a price.

## Examples

**Response**

```json
{
  "price_codes": [
    {
      "price_code": "Cust_1",
      "price": "24.90"
    },
    {
      "price_code": "Ship_US",
      "price": "26.00"
    }
  ]
}
```

**SDK Code**

```python Result
import requests

url = "https://restapi.ordergroove.com/products/product_id/price_codes/"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Result
const url = 'https://restapi.ordergroove.com/products/product_id/price_codes/';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://restapi.ordergroove.com/products/product_id/price_codes/"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	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/products/product_id/price_codes/")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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.get("https://restapi.ordergroove.com/products/product_id/price_codes/")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://restapi.ordergroove.com/products/product_id/price_codes/', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp Result
using RestSharp;

var client = new RestClient("https://restapi.ordergroove.com/products/product_id/price_codes/");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift Result
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://restapi.ordergroove.com/products/product_id/price_codes/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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