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

# Obtener Precio del Producto (v4)

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

Devuelve la información de precios para un servicio de Megaport especificado por el `productUid`.

Esta configuración puede ser para un producto completamente nuevo o para un producto existente.

Al obtener precios para un producto existente, puede anular ciertos parámetros, como `speed` o `term`, para ver cuánto costaría su servicio actual si cambiara la velocidad o recontratara el servicio.

Puede devolver precios para estos servicios:

- Puerto
    
- VXC
    
- Internet Megaport
    
- MCR
    
- MVE
    
- IX
    
- Dirección IP
    

La solicitud será rechazada si el tipo de producto no es compatible.

Las configuraciones de complementos se pueden pasar como parte del cuerpo de la solicitud y el precio del complemento se incluirá en la respuesta.

Los parámetros están definidos en el cuerpo de la solicitud:

- `productType` - El tipo de producto para la solicitud de precios. Los valores válidos incluyen: MEGAPORT, VXC, MCR2, MVE, IX, IP_ADDRESS (Cadena).
    
- `currency` - El código de moneda ISO 4217 que se utilizará para precios. Por ejemplo, el dólar estadounidense es USD. Si no se proporciona, el valor predeterminado es la moneda del producto existente. Si no se especifica el producto, se debe proporcionar la moneda. Para obtener más información, consulte [Códigos de moneda por país](https://www.iban.com/currency-codes). (Cadena)
    
- `LocationId` (Puerto/MCR/MVE/Dirección IP) - El id del lugar donde se implementará el servicio (Entero - Requerido).
    
- `Vendor` (MVE) - El nombre del proveedor que se utilizará en los cálculos de precios. Por ejemplo, `Cisco` (Cadena).
    
- `Size` (MVE) - El tamaño de MVE que se utilizará en los cálculos de precios. Si se proporcionan tanto el tamaño como la etiqueta de MVE, el punto final solo aceptará la etiqueta de MVE como tamaño de MVE (Cadena).
    
- `mveLabel` (MVE) - El tamaño de la VM. El tamaño define las especificaciones de MVE, incluidos el número de núcleos, el ancho de banda y el número de conexiones (Cadena).
    
- `portLocationId` (IX) - El identificador de ubicación del puerto para la conexión IX (Entero - Requerido).
    
- `ixType` (IX) - El tipo de intercambio de Internet, por ejemplo, Brisbane IX (Cadena - Requerido).
    
- `ipBlock` (Dirección IP) - El tamaño de subred para especificar cuántas direcciones IP son necesarias. Los valores válidos incluyen: /24, /25, /26, /27, /28, /29, /30 (Cadena - Requerido).
    
- `aLocationId` (VXC) - El id de la ubicación A-End del VXC (Requerido - Entero).
    
- `bLocationId` - (VXC) - El id de la ubicación B-End del VXC (Requerido - Entero).
    
- `speed` - La velocidad del servicio en Mbps (Entero).
    
- `aEndProductType` (VXC) - El tipo de producto del servicio A-End del VXC. Los valores válidos incluyen: MEGAPORT, VXC, MCR2, MVE, IX, IP_ADDRESS (Cadena).
    
- `connectType` (VXC) - El tipo de conexión del VXC, que normalmente es el mismo que el tipo de conexión del servicio B-End. Los valores válidos incluyen: MVE, AMSIX, AWS (para Hosted VIF), AWSHC (para Hosted Connection), AZURE, GOOGLE, ORACLE, OUTSCALE, ALIBABA e IBM. Use connectType=TRANSIT para Puertos que admitan una conexión a Internet Megaport. Use connectType=FRANCEIX para Puertos a los que puede crear un VXC para conectarse a France-IX (Cadena).
    
- `productUid` - El identificador único del producto (Cadena).
    
- `term` - Plazo del contrato en meses (Entero).
    
- `addOns` - Lista de solicitudes de libro de precios de complementos (Matriz).

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

## Servers

- `https://api.megaport.com` (Entorno de producción, default)
- `https://api-staging.megaport.com` (Entorno de pruebas (solo pruebas, se restablece cada 24 horas))

## Request

### Query parameters

- `companyId` (string, optional) — El identificador de la empresa que será propietaria del producto. Si no se proporciona, se establecerá por defecto a la empresa del usuario autenticado. Esto se puede suministrar con productUid para recuperar el precio de un producto existente, pero en el contexto de otra empresa. (Opcional - entero \<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

Obtener precio del producto (v4) - Puerto / Obtener precio del producto (v4) - Puerto 2 / Obtener precio del producto (v4) - VXC / Obtener precio del producto (v4) - MCR / Obtener precio del producto (v4) - MVE / Obtener precio del producto (v4) - IX / Obtener precio del producto (v4) - VXC / Obtener precio del producto (v4) - Puerto / Obtener precio del producto (v4) - MCR / Obtener precio del producto (v4) - Puerto 2 / Obtener precio del producto (v4) - IX / Obtener precio del producto (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": "Precio del producto",
  "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": "Precio del producto",
  "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": "Precio del producto",
  "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": "Datos creados exitosamente",
  "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": "Precio del producto",
  "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": "Precio del producto",
  "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": "Precio del producto",
  "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()
```