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

# Get Product Price (v4)

POST https://api.megaport.com/v4/pricebook/product
Content-Type: application/json

Returns the pricing information for a Megaport service specified by the `productUid`.

This configuration can be for an entirely new prospective product or for an existing product.

When fetching pricing for an existing product, you can override certain parameters, such as `speed` or `term`, to see how much your current service would cost if you were to change the speed or reterm the service.

You can return pricing for these services:

- Port
    
- VXC
    
- Megaport Internet
    
- MCR
    
- MVE
    
- IX
    
- IP Address
    

The request will be rejected if the product type is not supported.

The configurations of add-ons can be passed as part of the request Body and the add-on pricing will be included in the response.

The parameters are defined in the Body of the request:

- `productType` - The type of product for the pricing request. Valid values include: MEGAPORT, VXC, MCR2, MVE, IX, IP_ADDRESS (String).
    
- `currency` - The ISO 4217 currency code to use for pricing. For example, the US dollar is USD. If not provided, defaults to the existing product's currency. If the product is not specified, currency must be provided. For more information, see [Country Currency Codes](https://www.iban.com/currency-codes). (String)
    
- `LocationId` (Port/MCR/MVE/IP Address) - The id of location where the service will be deployed (Integer - Required).
    
- `Vendor` (MVE) - The provider name to use in the price calculations. For example, `Cisco` (String).
    
- `Size` (MVE) - The MVE size to use in price calculations. If both size and mveLabel are supplied, the endpoint will only accept mveLabel as the MVE size (String).
    
- `mveLabel` (MVE) - The size of the VM. The size defines the MVE specifications including number of cores, bandwidth, and number of connections (String).
    
- `portLocationId` (IX) - The port location identifier for the IX connection (Integer - Required).
    
- `ixType` (IX) - The type of Internet Exchange, for example, Brisbane IX (String - Required).
    
- `ipBlock` (IP Address) - The subnet size to specify how many IP addresses are required. Valid values include: /24, /25, /26, /27, /28, /29, /30 (String - Required).
    
- `aLocationId` (VXC) - The id of the A-End location of the VXC (Required - Integer).
    
- `bLocationId` - (VXC) - The id of the B-End location of the VXC (Required - Integer).
    
- `speed` - The service speed in Mbps (Integer).
    
- `aEndProductType` (VXC) - The product type of the A-End service of the VXC. Valid values include: MEGAPORT, VXC, MCR2, MVE, IX, IP_ADDRESS (String).
    
- `connectType` (VXC) - The connect type of the VXC, which is typically the same as the connect type of the B-End service. Valid values include: MVE, AMSIX, AWS (for Hosted VIF), AWSHC (for Hosted Connection), AZURE, GOOGLE, ORACLE, OUTSCALE, ALIBABA, and IBM. Use connectType=TRANSIT for Ports that support a Megaport Internet connection. Use connectType=FRANCEIX for Ports that you can create a VXC to in order to connect to France-IX (String).
    
- `productUid` - The unique identifier for the product (String).
    
- `term` - The contract term in months (Integer).
    
- `addOns` - List of add-on price book requests (Array).

Reference: https://en.megaport.ferndocs.com/api-reference/pricing/get-product-price-v-4

## Servers

- `https://api.megaport.com` (Production environment, default)
- `https://api-staging.megaport.com` (Staging environment (test only, reset every 24 hours))

## Request

### Query parameters

- `companyId` (string, optional) — The Id of the company that will own the product. If not provided, it will default to the authenticated user's company. This can be supplied with productUid to fetch the pricing of an existing product, but in the context of another company. (Optional - integer \<int32> >= 1)

### Body (application/json)

This endpoint expects an object.

- `currency` (string, optional)
- `locationId` (double, optional)
- `mveLabel` (string, optional)
- `productType` (string, optional)
- `productUid` (string, optional)
- `size` (string, optional)
- `term` (double, optional)
- `vendor` (string, optional)

## Response

### 200

Get Product Price (v4) - Port / Get Product Price (v4) - Port 2 / Get Product Price (v4) - VXC / Get Product Price (v4) - MCR / Get Product Price (v4) - MVE / Get Product Price (v4) - IX / Get Product Price (v4) - VXC / Get Product Price (v4) - Port / Get Product Price (v4) - MCR / Get Product Price (v4) - Port 2 / Get Product Price (v4) - IX / Get Product Price (v4) - MVE

- `data` (V4PricebookProductPostResponsesContentApplicationJsonSchemaData, optional)
- `message` (string, optional)
- `terms` (string, optional)

## Types

### V4PricebookProductPostResponsesContentApplicationJsonSchemaData

- `currency` (string, optional)
- `discounts` (list of V4PricebookProductPostResponsesContentApplicationJsonSchemaDataDiscountsItems, optional)
- `monthlyRackRate` (double, optional)
- `monthlyRate` (double, optional)
- `prices` (list of V4PricebookProductPostResponsesContentApplicationJsonSchemaDataPricesItems, optional)
- `productType` (string, optional)

### V4PricebookProductPostResponsesContentApplicationJsonSchemaDataDiscountsItems

- `amount` (double, optional)
- `discountDetails` (V4PricebookProductPostResponsesContentApplicationJsonSchemaDataDiscountsItemsDiscountDetails, optional)
- `discountReason` (string, optional)

### V4PricebookProductPostResponsesContentApplicationJsonSchemaDataPricesItems

- `amount` (double, optional)
- `chargeReason` (string, optional)
- `frequency` (string, optional)

### V4PricebookProductPostResponsesContentApplicationJsonSchemaDataDiscountsItemsDiscountDetails

- `percentageAmount` (double, optional)

## Examples

### Get Product Price (v4) - IX

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [],
    "monthlyRackRate": 9785.45454545455,
    "monthlyRate": 9785.45454545455,
    "prices": [],
    "productType": "IX"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - IX
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - IX
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - IX
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - IX
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - IX
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - IX
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - IX
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - IX
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4) - MCR

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [
      {
        "amount": 0,
        "discountDetails": {
          "percentageAmount": {},
          "code": {},
          "description": {},
          "mechanism": {}
        },
        "discountReason": "TERM"
      }
    ],
    "monthlyRackRate": 600,
    "monthlyRate": 400,
    "prices": [],
    "productType": "MCR2"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - MCR
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - MCR
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - MCR
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - MCR
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - MCR
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - MCR
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - MCR
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - MCR
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4) - MVE

**Response**

```json
{
  "data": {
    "currency": "USD",
    "discounts": [
      {
        "amount": 550,
        "discountDetails": {
          "percentageAmount": {},
          "code": {},
          "description": {},
          "mechanism": {}
        },
        "discountReason": "TERM"
      }
    ],
    "monthlyRackRate": 3300,
    "monthlyRate": 2750,
    "prices": [],
    "productType": "MVE"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - MVE
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - MVE
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - MVE
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - MVE
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - MVE
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - MVE
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - MVE
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - MVE
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4) - Port

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [
      {
        "amount": 10,
        "discountDetails": {
          "percentageAmount": 15.5
        },
        "discountReason": "TERM"
      }
    ],
    "monthlyRackRate": 150,
    "monthlyRate": 100,
    "prices": [
      {
        "amount": 50,
        "chargeReason": "CORE",
        "frequency": "MONTHLY"
      }
    ],
    "productType": "MEGAPORT"
  },
  "message": "Data created successfully",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - Port
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - Port
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - Port
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - Port
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - Port
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - Port
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - Port
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - Port
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4) - Port 2

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [
      {
        "amount": 400,
        "discountDetails": {
          "percentageAmount": {},
          "code": {},
          "description": {},
          "mechanism": {}
        },
        "discountReason": "TERM"
      }
    ],
    "monthlyRackRate": 2400,
    "monthlyRate": 2000,
    "prices": [],
    "productType": "MEGAPORT"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - Port 2
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - Port 2
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - Port 2
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - Port 2
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - Port 2
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - Port 2
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - Port 2
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - Port 2
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4) - VXC

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [
      {
        "amount": 20,
        "discountDetails": {
          "percentageAmount": {},
          "code": {},
          "description": {},
          "mechanism": {}
        },
        "discountReason": "TERM"
      }
    ],
    "monthlyRackRate": 120,
    "monthlyRate": 100,
    "prices": [],
    "productType": "VXC"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4) - VXC
import requests

url = "https://api.megaport.com/v4/pricebook/product"

response = requests.post(url)

print(response.json())
```

```javascript Get Product Price (v4) - VXC
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {method: 'POST'};

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

```go Get Product Price (v4) - VXC
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

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

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

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

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

}
```

```ruby Get Product Price (v4) - VXC
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)

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

```java Get Product Price (v4) - VXC
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .asString();
```

```php Get Product Price (v4) - VXC
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product');

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

```csharp Get Product Price (v4) - VXC
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4) - VXC
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

### Get Product Price (v4)

**Request**

```json
{
  "currency": "AUD",
  "locationId": 123,
  "mveLabel": "MVE 16/64",
  "productType": "MVE",
  "productUid": "8afe49da-e936-4e2d-a1dd-03e2c6525108",
  "size": "large",
  "term": 12,
  "vendor": "cisco"
}
```

**Response**

```json
{
  "data": {
    "currency": "AUD",
    "discounts": [],
    "monthlyRackRate": 9785.45454545455,
    "monthlyRate": 9785.45454545455,
    "prices": [],
    "productType": "IX"
  },
  "message": "Product price",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Get Product Price (v4)
import requests

url = "https://api.megaport.com/v4/pricebook/product"

payload = {
    "currency": "AUD",
    "locationId": 123,
    "mveLabel": "MVE 16/64",
    "productType": "MVE",
    "productUid": "8afe49da-e936-4e2d-a1dd-03e2c6525108",
    "size": "large",
    "term": 12,
    "vendor": "cisco"
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Get Product Price (v4)
const url = 'https://api.megaport.com/v4/pricebook/product';
const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: '{"currency":"AUD","locationId":123,"mveLabel":"MVE 16/64","productType":"MVE","productUid":"8afe49da-e936-4e2d-a1dd-03e2c6525108","size":"large","term":12,"vendor":"cisco"}'
};

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

```go Get Product Price (v4)
package main

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

func main() {

	url := "https://api.megaport.com/v4/pricebook/product"

	payload := strings.NewReader("{\n  \"currency\": \"AUD\",\n  \"locationId\": 123,\n  \"mveLabel\": \"MVE 16/64\",\n  \"productType\": \"MVE\",\n  \"productUid\": \"8afe49da-e936-4e2d-a1dd-03e2c6525108\",\n  \"size\": \"large\",\n  \"term\": 12,\n  \"vendor\": \"cisco\"\n}")

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

	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 Get Product Price (v4)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v4/pricebook/product")

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

request = Net::HTTP::Post.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"currency\": \"AUD\",\n  \"locationId\": 123,\n  \"mveLabel\": \"MVE 16/64\",\n  \"productType\": \"MVE\",\n  \"productUid\": \"8afe49da-e936-4e2d-a1dd-03e2c6525108\",\n  \"size\": \"large\",\n  \"term\": 12,\n  \"vendor\": \"cisco\"\n}"

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

```java Get Product Price (v4)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.megaport.com/v4/pricebook/product")
  .header("Content-Type", "application/json")
  .body("{\n  \"currency\": \"AUD\",\n  \"locationId\": 123,\n  \"mveLabel\": \"MVE 16/64\",\n  \"productType\": \"MVE\",\n  \"productUid\": \"8afe49da-e936-4e2d-a1dd-03e2c6525108\",\n  \"size\": \"large\",\n  \"term\": 12,\n  \"vendor\": \"cisco\"\n}")
  .asString();
```

```php Get Product Price (v4)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.megaport.com/v4/pricebook/product', [
  'body' => '{
  "currency": "AUD",
  "locationId": 123,
  "mveLabel": "MVE 16/64",
  "productType": "MVE",
  "productUid": "8afe49da-e936-4e2d-a1dd-03e2c6525108",
  "size": "large",
  "term": 12,
  "vendor": "cisco"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Get Product Price (v4)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v4/pricebook/product");
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"currency\": \"AUD\",\n  \"locationId\": 123,\n  \"mveLabel\": \"MVE 16/64\",\n  \"productType\": \"MVE\",\n  \"productUid\": \"8afe49da-e936-4e2d-a1dd-03e2c6525108\",\n  \"size\": \"large\",\n  \"term\": 12,\n  \"vendor\": \"cisco\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Get Product Price (v4)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "currency": "AUD",
  "locationId": 123,
  "mveLabel": "MVE 16/64",
  "productType": "MVE",
  "productUid": "8afe49da-e936-4e2d-a1dd-03e2c6525108",
  "size": "large",
  "term": 12,
  "vendor": "cisco"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v4/pricebook/product")! 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()
```