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

# Actualizar VXC (v3)

PUT https://api.megaport.com/v3/product/vxc/{productUid}
Content-Type: application/json

Actualiza la información editable para un VXC.

El `productUid` identifica el VXC.

**Consejo:** Utilice el endpoint `/v2/product` para determinar el `productUid`.

Los cambios se definen en el cuerpo de la solicitud. Solo incluya los parámetros que desee actualizar. Para un VXC, puede actualizar los siguientes parámetros:

- `name` - Nombre del cliente para la conexión - este nombre aparece en el Portal.
    
- `rateLimit` - Una nueva velocidad para la conexión.
    
- `aEndVlan` - Un ID de VLAN único para esta conexión. Los valores pueden oscilar entre 2 y 4093. Si este valor es 0, el sistema asigna un VLAN válido.
    
- `bEndVlan` - Un ID de VLAN único para esta conexión. Los valores pueden oscilar entre 2 y 4093. Si este valor es 0, el sistema asigna un VLAN válido.
    
- `term` - Configurar un término para este VXC. Tenga en cuenta que hay reglas para los términos. Consulte **Términos de VXC** a continuación para obtener más información.
    
- `costCentre` - Un número de referencia de cliente que se incluirá en la información de facturación y facturas
    
- `aEndProductUid` - Al mover un VXC, este es el nuevo A-End para la conexión.
    
- `bEndProductUid` - Al mover un VXC, este es el nuevo B-End para la conexión.
    
- `aVnicIndex` - Al mover un VXC para un MVE, este es el nuevo vNIC A-End para la conexión.
    
- `bVnicIndex` - Al mover un VXC para un MVE, este es el nuevo vNIC B-End para la conexión.
    
- `isApproved` - Definir si el VXC está aprobado o rechazado a través del Mercado de Megaport. Establecer en `true` (Aprobado) o `false` (Rechazado).  
    **Nota:** Válido solo si hay un pedido pendiente de aprobación (nueva solicitud de mercado o cambio de velocidad). Si no hay pedidos pendientes de aprobación y se envía `isApproved` en la solicitud, la API devolverá un error.
    
- `shutdown` - Apagar y volver a habilitar temporalmente el VXC. Los valores válidos son `true` (apagado) y `false` (habilitado). Si no se proporciona, el valor predeterminado es `false` (habilitado).
    

Para obtener más información, consulte [Cambiar la configuración de un VXC con la API](https://docs.megaport.com/api/api-vxc-change/).

**Nota:** Solo puede actualizar un producto cuando su estado de aprovisionamiento es `CONFIGURED` o `LIVE`.

#### Términos de VXC

Puede actualizar el término del VXC actualizando el campo `term`.

Se aplican las siguientes reglas para actualizar los términos de VXC:

- Si la validación falla, el término se establece por defecto en Sin Término Mínimo, `contractTermMonths:1`.
    
- La velocidad no puede cambiarse cuando el VXC está en término.
    
- Solo puede cambiar la velocidad si el VXC está Sin Término Mínimo, si el término ha expirado o si se reetermina a un término más largo.
    
- Si está actualizando un VXC en término, solo puede reeterminar a un término superior. Si necesita cambiar la velocidad, solo puede cambiarla a un límite de tasa superior.
    
- Si está actualizando un VXC expirado en término, se puede seleccionar cualquier término y/o velocidad.
    
- No puede cambiar un VXC de un término (12/24/36 meses) a mes a mes/Sin Término Mínimo a menos que el término haya expirado.
    
- No puede reeterminar un VXC si el servicio tiene un precio no estándar.
    
- Puede mover o apagar VXCs en término.
    

#### Mover VXC

Puede mover un VXC actualizando el A-End o B-End o ambos, utilizando los campos `aEndProductUid` y `bEndProductUid`. Al mover un VXC para un MVE, también puede seleccionar los vNICs en el A-End y B-End utilizando los campos `aVnicIndex` y `bVnicIndex`.

Las siguientes reglas determinan dónde y cómo se puede mover un VXC:

- El nuevo Puerto puede estar en una ubicación diferente pero debe estar en la **misma área metropolitana**.
    
- El nuevo Puerto debe ser del mismo tipo. Por ejemplo, MEGAPORT a MEGAPORT, MCR a MCR o MVE a MVE.
    
- La velocidad configurada de cada VXC no debe ser mayor que la velocidad del Puerto de destino. Si se está degradando, es posible que deba reducir la velocidad del VXC antes de solicitar el movimiento.
    
- No debe haber conflicto de direcciones IP o VLAN. Los servicios actualizados se comprueban como si se estuviera solicitando un nuevo servicio. Por ejemplo, un VLAN sin etiqueta no puede moverse a un servicio que ya tiene un VLAN sin etiqueta.
    
- Los servicios que se mueven deben tener ID de VLAN diferentes de cualquier servicio ya existente en el destino.
    

Si el movimiento de VXC no es válido, el movimiento fallará.

Para obtener más información, consulte [Mover VXCs](https://docs.megaport.com/connections/move-vxc/) y [Mover un VXC e IX con la API](https://docs.megaport.com/api/api-vxc-move/).

Reference: https://es.megaport.ferndocs.com/es/api-reference/megaport-virtual-edge-mve/update-vxc-v-3

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

### Path parameters

- `productUid` (string, required)

### Body (application/json)

This endpoint expects an object.

- `aEndInnerVlan` (double, optional)
- `aEndVlan` (double, optional)
- `bEndInnerVlan` (double, optional)
- `costCentre` (string, optional)
- `name` (string, optional)
- `rateLimit` (double, optional)
- `term` (double, optional)

## Response

### 200

Actualizar VXC (v3) / Mover VXC (v3) / Mover VXC para MVE - Actualizar vNICs en Ambos Extremos (v3) / Mover VXC para MVE - Cambiar Extremo B para Conectar a MVE con Múltiples vNICs (v3) / Apagar VXC (v3) / Volver a Habilitar VXC (v3) / Actualizar Término VXC (v3) / Mover VXC (v3) / Mover VXC para MVE - Cambiar Extremo B para Conectar a MVE con Múltiples vNICs (v3) / Actualizar VXC (v3) / Actualizar Término VXC (v3) / Mover VXC para MVE - Actualizar vNICs en Ambos Extremos (v3) / Apagar VXC (v3) / Volver a Habilitar VXC (v3) / Actualizar Internet Megaport (v3) / Actualizar Internet Megaport (v3) - Término de Contrato de 12 Meses / Actualizar Internet Megaport (v3) - Término de Contrato de 24 Meses / Actualizar Internet Megaport (v3) - Mover / Actualizar Internet Megaport (v3) - Apagar / Actualizar Internet Megaport (v3) - Volver a Habilitar / Actualizar Internet Megaport (v3) / Actualizar Internet Megaport (v3) - Término de Contrato de 12 Meses / Actualizar Internet Megaport (v3) - Volver a Habilitar / Actualizar Internet Megaport (v3) - Apagar / Actualizar Internet Megaport (v3) - Mover / Actualizar Internet Megaport (v3) - Término de Contrato de 24 Meses / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de VIF Alojado de AWS (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de Azure (v3) / Actualizar VXC de Google (v3) / Actualizar VXC de Google (v3) / Actualizar VXC para MCR (v3) - Límite de velocidad y etiquetas / Actualizar VXC para MCR (v3) - Varios cambios / Actualizar VXC para MCR (v3) - Límite de velocidad y etiquetas / Actualizar VXC para MCR (v3) - Varios cambios / Actualizar Internet Megaport (v3) / Actualizar Internet Megaport (v3) - Término de Contrato de 12 Meses / Actualizar Internet Megaport (v3) / Actualizar Internet Megaport (v3) - Término de Contrato de 12 Meses

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

## Types

### V3ProductVxcProductUidPutResponsesContentApplicationJsonSchemaData

- `aCountry` (any, optional, nullable)
- `aLocation` (any, optional, nullable)
- `aLocationId` (any, optional, nullable)
- `aMetro` (any, optional, nullable)
- `accountManager` (any, optional, nullable)
- `adminContactId` (any, optional, nullable)
- `adminContactName` (any, optional, nullable)
- `adminLocked` (boolean, optional)
- `aggregationId` (any, optional, nullable)
- `attributeTags` (V3ProductVxcProductUidPutResponsesContentApplicationJsonSchemaDataAttributeTags, optional)
- `attributes` (list of any, optional)
- `bCountry` (any, optional, nullable)
- `bLocation` (any, optional, nullable)
- `bLocationId` (any, optional, nullable)
- `bMetro` (any, optional, nullable)
- `bgpShutdownDefault` (boolean, optional)
- `billableId` (double, optional)
- `billableUsageAlgorithm` (any, optional, nullable)
- `billingContactId` (any, optional, nullable)
- `billingContactName` (any, optional, nullable)
- `buyoutPort` (any, optional, nullable)
- `companyId` (double, optional)
- `companyName` (string, optional)
- `components` (list of any, optional)
- `configuredDate` (double, optional)
- `contractStartDate` (any, optional, nullable)
- `contractTermMonths` (double, optional)
- `costCentre` (string, optional)
- `createDate` (double, optional)
- `createdBy` (string, optional)
- `crossConnectRequested` (boolean, optional)
- `currentEstimatedDelivery` (any, optional, nullable)
- `errorMessage` (any, optional, nullable)
- `failedReason` (any, optional, nullable)
- `inAdvanceBillingStatus` (any, optional, nullable)
- `intercapPath` (string, optional)
- `lagId` (any, optional, nullable)
- `lagPrimary` (boolean, optional, nullable)
- `locked` (boolean, optional)
- `market` (string, optional)
- `marketplaceVisibility` (boolean, optional)
- `maximumSpeed` (any, optional, nullable)
- `minimumSpeed` (any, optional, nullable)
- `name` (string, optional)
- `nonPayerCompanyId` (any, optional, nullable)
- `originDomain` (any, optional, nullable)
- `payerCompanyId` (any, optional, nullable)
- `productType` (string, optional)
- `promptUid` (any, optional, nullable)
- `provisioningItems` (list of any, optional)
- `provisioningStatus` (string, optional)
- `rateLimit` (double, optional)
- `rateType` (string, optional)
- `requestedDate` (double, optional)
- `salesId` (any, optional, nullable)
- `salesName` (any, optional, nullable)
- `secondaryName` (string, optional, nullable)
- `serviceName` (string, optional)
- `tags` (list of any, optional)
- `technicalContactId` (any, optional, nullable)
- `technicalContactName` (any, optional, nullable)
- `technicalServiceId` (double, optional)
- `technicalServiceUid` (string, optional)
- `terminationDate` (any, optional, nullable)
- `trialAgreement` (boolean, optional)
- `virtual` (boolean, optional)
- `vxcAutoApproval` (boolean, optional)
- `vxcDistanceBand` (string, optional)
- `vxcPermitted` (boolean, optional)

### V3ProductVxcProductUidPutResponsesContentApplicationJsonSchemaDataAttributeTags

## Examples

### Move VXC (v3)

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Move VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Move VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Move VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Move VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Move VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Move VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Move VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Move VXC (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)

**Response**

```json
{
  "data": {
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bgpShutdownDefault": false,
    "billableId": 69751,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1605048425572,
    "contractTermMonths": 1,
    "createDate": 1605048397911,
    "createdBy": "52a26471-94de-4d32-b89e-0cd5d26c1f65",
    "intercapPath": "",
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "name": "Updated Name for VXC LA to Bay Area",
    "productType": "VXC",
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1605048397012,
    "serviceName": "Updated Name for VXC LA to Bay Area",
    "tags": [],
    "technicalServiceId": 70670,
    "technicalServiceUid": "8d360672-7aff-42b2-be6d-ce58a2927459",
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "ZONE",
    "vxcPermitted": true
  },
  "message": "VXC 70670 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Move VXC for MVE - Update vNICs on Both Ends (v3)

**Response**

```json
{
  "data": {
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bgpShutdownDefault": false,
    "billableId": 69751,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1605048425572,
    "contractTermMonths": 1,
    "createDate": 1605048397911,
    "createdBy": "52a26471-94de-4d32-b89e-0cd5d26c1f65",
    "intercapPath": "",
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "name": "Updated Name for VXC LA to Bay Area",
    "productType": "VXC",
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1605048397012,
    "serviceName": "Updated Name for VXC LA to Bay Area",
    "tags": [],
    "technicalServiceId": 70670,
    "technicalServiceUid": "8d360672-7aff-42b2-be6d-ce58a2927459",
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "ZONE",
    "vxcPermitted": true
  },
  "message": "VXC 70670 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Move VXC for MVE - Update vNICs on Both Ends (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Move VXC for MVE - Update vNICs on Both Ends (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Move VXC for MVE - Update vNICs on Both Ends (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Move VXC for MVE - Update vNICs on Both Ends (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Move VXC for MVE - Update vNICs on Both Ends (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Move VXC for MVE - Update vNICs on Both Ends (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Move VXC for MVE - Update vNICs on Both Ends (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Move VXC for MVE - Update vNICs on Both Ends (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Re-enable VXC (v3)

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 158594,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1689163563726,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1689163529437,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Japan",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "GB VXC",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 500,
    "rateType": "MONTHLY",
    "requestedDate": 1689163529388,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "GB VXC",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 166698,
    "technicalServiceUid": "a459325a-4cf4-4460-a12c-2628436b1080",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "INTERZONE",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 166698",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Re-enable VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Re-enable VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Re-enable VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Re-enable VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Re-enable VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Re-enable VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Re-enable VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Re-enable VXC (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Shut Down VXC (v3)

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 158594,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1689163563726,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1689163529437,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Japan",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "GB VXC",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "CONFIGURED",
    "rateLimit": 500,
    "rateType": "MONTHLY",
    "requestedDate": 1689163529388,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "GB VXC",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 166698,
    "technicalServiceUid": "a459325a-4cf4-4460-a12c-2628436b1080",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "INTERZONE",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 166698",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Shut Down VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Shut Down VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Shut Down VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Shut Down VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Shut Down VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Shut Down VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Shut Down VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Shut Down VXC (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update AWS Hosted VIF VXC (v3)

**Request**

```json
{
  "aEndInnerVlan": 2,
  "costCentre": "Service level reference",
  "name": "Updated AWS VXC name",
  "rateLimit": 1000
}
```

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 147629,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1680239102916,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "Service level reference",
    "createDate": 1680239079620,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated AWS VXC name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1680239079588,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated AWS VXC name",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 155724,
    "technicalServiceUid": "92e5c7d6-8d97-4ee3-bbf9-13e69b49517c",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "INTERZONE",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 155724",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update AWS Hosted VIF VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndInnerVlan": 2,
    "costCentre": "Service level reference",
    "name": "Updated AWS VXC name",
    "rateLimit": 1000
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update AWS Hosted VIF VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndInnerVlan":2,"costCentre":"Service level reference","name":"Updated AWS VXC name","rateLimit":1000}'
};

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

```go Update AWS Hosted VIF VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndInnerVlan\": 2,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated AWS VXC name\",\n  \"rateLimit\": 1000\n}")

	req, _ := http.NewRequest("PUT", 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 Update AWS Hosted VIF VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndInnerVlan\": 2,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated AWS VXC name\",\n  \"rateLimit\": 1000\n}"

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

```java Update AWS Hosted VIF VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndInnerVlan\": 2,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated AWS VXC name\",\n  \"rateLimit\": 1000\n}")
  .asString();
```

```php Update AWS Hosted VIF VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndInnerVlan": 2,
  "costCentre": "Service level reference",
  "name": "Updated AWS VXC name",
  "rateLimit": 1000
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update AWS Hosted VIF VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndInnerVlan\": 2,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated AWS VXC name\",\n  \"rateLimit\": 1000\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update AWS Hosted VIF VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndInnerVlan": 2,
  "costCentre": "Service level reference",
  "name": "Updated AWS VXC name",
  "rateLimit": 1000
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Azure VXC (v3)

**Request**

```json
{
  "aEndInnerVlan": 222,
  "bEndInnerVlan": 222,
  "costCentre": "New reference for invoice",
  "name": "Updated Azure VXC name",
  "rateLimit": 500
}
```

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 147640,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1680247022528,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "New reference for invoice",
    "createDate": 1680246964352,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated Azure VXC name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 500,
    "rateType": "MONTHLY",
    "requestedDate": 1680246964320,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated Azure VXC name",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 155735,
    "technicalServiceUid": "6cf7199e-a273-4352-97f7-3a772bc492e4",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "VXC 155735 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Azure VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndInnerVlan": 222,
    "bEndInnerVlan": 222,
    "costCentre": "New reference for invoice",
    "name": "Updated Azure VXC name",
    "rateLimit": 500
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Azure VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndInnerVlan":222,"bEndInnerVlan":222,"costCentre":"New reference for invoice","name":"Updated Azure VXC name","rateLimit":500}'
};

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

```go Update Azure VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndInnerVlan\": 222,\n  \"bEndInnerVlan\": 222,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated Azure VXC name\",\n  \"rateLimit\": 500\n}")

	req, _ := http.NewRequest("PUT", 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 Update Azure VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndInnerVlan\": 222,\n  \"bEndInnerVlan\": 222,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated Azure VXC name\",\n  \"rateLimit\": 500\n}"

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

```java Update Azure VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndInnerVlan\": 222,\n  \"bEndInnerVlan\": 222,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated Azure VXC name\",\n  \"rateLimit\": 500\n}")
  .asString();
```

```php Update Azure VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndInnerVlan": 222,
  "bEndInnerVlan": 222,
  "costCentre": "New reference for invoice",
  "name": "Updated Azure VXC name",
  "rateLimit": 500
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Azure VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndInnerVlan\": 222,\n  \"bEndInnerVlan\": 222,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated Azure VXC name\",\n  \"rateLimit\": 500\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Azure VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndInnerVlan": 222,
  "bEndInnerVlan": 222,
  "costCentre": "New reference for invoice",
  "name": "Updated Azure VXC name",
  "rateLimit": 500
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Google VXC (v3)

**Request**

```json
{
  "aEndInnerVlan": 300,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 50
}
```

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 146534,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1679500145603,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "Service level reference",
    "createDate": 1679500072128,
    "createdBy": "b0dedbd2-ecc7-4bad-a13b-6c34b4005115",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "locked": false,
    "market": "UK",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated VXC name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 50,
    "rateType": "MONTHLY",
    "requestedDate": 1679500072095,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated VXC name",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 154522,
    "technicalServiceUid": "d7f18e87-4e93-4138-8b39-57929c83cb28",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "VXC 154522 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Google VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndInnerVlan": 300,
    "costCentre": "Service level reference",
    "name": "Updated VXC name",
    "rateLimit": 50
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Google VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndInnerVlan":300,"costCentre":"Service level reference","name":"Updated VXC name","rateLimit":50}'
};

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

```go Update Google VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndInnerVlan\": 300,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 50\n}")

	req, _ := http.NewRequest("PUT", 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 Update Google VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndInnerVlan\": 300,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 50\n}"

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

```java Update Google VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndInnerVlan\": 300,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 50\n}")
  .asString();
```

```php Update Google VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndInnerVlan": 300,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 50
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Google VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndInnerVlan\": 300,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 50\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Google VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndInnerVlan": 300,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 50
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Megaport Internet (v3)

**Request**

```json
{
  "costCentre": "New reference for invoice",
  "name": "New Example connection name",
  "contractTermMonths": 12
}
```

**Response**

```json
{
  "data": {
    "adminLocked": false,
    "attributeTags": {},
    "attributes": [],
    "bgpShutdownDefault": false,
    "billableId": 69751,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1605048425572,
    "contractTermMonths": 1,
    "createDate": 1605048397911,
    "createdBy": "52a26471-94de-4d32-b89e-0cd5d26c1f65",
    "intercapPath": "",
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "name": "Updated Name for VXC LA to Bay Area",
    "productType": "VXC",
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1605048397012,
    "serviceName": "Updated Name for VXC LA to Bay Area",
    "tags": [],
    "technicalServiceId": 70670,
    "technicalServiceUid": "8d360672-7aff-42b2-be6d-ce58a2927459",
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "ZONE",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 70670",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "costCentre": "New reference for invoice",
    "name": "New Example connection name",
    "contractTermMonths": 12
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Megaport Internet (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"costCentre":"New reference for invoice","name":"New Example connection name","contractTermMonths":12}'
};

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

```go Update Megaport Internet (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"New Example connection name\",\n  \"contractTermMonths\": 12\n}")

	req, _ := http.NewRequest("PUT", 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 Update Megaport Internet (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"New Example connection name\",\n  \"contractTermMonths\": 12\n}"

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

```java Update Megaport Internet (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"New Example connection name\",\n  \"contractTermMonths\": 12\n}")
  .asString();
```

```php Update Megaport Internet (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "costCentre": "New reference for invoice",
  "name": "New Example connection name",
  "contractTermMonths": 12
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Megaport Internet (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"New Example connection name\",\n  \"contractTermMonths\": 12\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "costCentre": "New reference for invoice",
  "name": "New Example connection name",
  "contractTermMonths": 12
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Megaport Internet (v3) - 12 Month Contract Term

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 174782,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1702969121520,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "New reference for invoice",
    "createDate": 1702969112299,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "New Example connection name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 5000,
    "rateType": "MONTHLY",
    "requestedDate": 1702969112273,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "New Example connection name",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 182960,
    "technicalServiceUid": "0dd89e25-2821-4f06-8297-c1331b3d79ee",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 182960",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3) - 12 Month Contract Term
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update Megaport Internet (v3) - 12 Month Contract Term
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update Megaport Internet (v3) - 12 Month Contract Term
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update Megaport Internet (v3) - 12 Month Contract Term
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update Megaport Internet (v3) - 12 Month Contract Term
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update Megaport Internet (v3) - 12 Month Contract Term
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update Megaport Internet (v3) - 12 Month Contract Term
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3) - 12 Month Contract Term
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update Megaport Internet (v3) - 24 Month Contract Term

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 174787,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1702978176460,
    "contractStartDate": null,
    "contractTermMonths": 24,
    "costCentre": "Another reference for invoice",
    "createDate": 1702978172144,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Another Name for Megaport Internet Connection",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 5000,
    "rateType": "MONTHLY",
    "requestedDate": 1702978172118,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Another Name for Megaport Internet Connection",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 182965,
    "technicalServiceUid": "99de0dd5-7343-4a3b-93a0-927252c6da1b",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 182965",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3) - 24 Month Contract Term
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update Megaport Internet (v3) - 24 Month Contract Term
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update Megaport Internet (v3) - 24 Month Contract Term
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update Megaport Internet (v3) - 24 Month Contract Term
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update Megaport Internet (v3) - 24 Month Contract Term
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update Megaport Internet (v3) - 24 Month Contract Term
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update Megaport Internet (v3) - 24 Month Contract Term
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3) - 24 Month Contract Term
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update Megaport Internet (v3) - Move

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 172148,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1700638847219,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "New reference for invoice",
    "createDate": 1700638839857,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "New Name for Megaport Internet Connection",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 5000,
    "rateType": "MONTHLY",
    "requestedDate": 1700638839827,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "New Name for Megaport Internet Connection",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 180323,
    "technicalServiceUid": "eef2fb0a-dac6-4d24-8000-64aa0918c145",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 180323",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3) - Move
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update Megaport Internet (v3) - Move
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update Megaport Internet (v3) - Move
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update Megaport Internet (v3) - Move
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update Megaport Internet (v3) - Move
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update Megaport Internet (v3) - Move
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update Megaport Internet (v3) - Move
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3) - Move
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update Megaport Internet (v3) - Re-enable

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 172148,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1700638847219,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "New reference for invoice",
    "createDate": 1700638839857,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "New Name for Megaport Internet Connection",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 5000,
    "rateType": "MONTHLY",
    "requestedDate": 1700638839827,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "New Name for Megaport Internet Connection",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 180323,
    "technicalServiceUid": "eef2fb0a-dac6-4d24-8000-64aa0918c145",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 180323",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3) - Re-enable
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update Megaport Internet (v3) - Re-enable
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update Megaport Internet (v3) - Re-enable
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update Megaport Internet (v3) - Re-enable
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update Megaport Internet (v3) - Re-enable
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update Megaport Internet (v3) - Re-enable
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update Megaport Internet (v3) - Re-enable
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3) - Re-enable
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update Megaport Internet (v3) - Shut Down

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 172148,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1700638847219,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "New reference for invoice",
    "createDate": 1700638839857,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "New Name for Megaport Internet Connection",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 5000,
    "rateType": "MONTHLY",
    "requestedDate": 1700638839827,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "New Name for Megaport Internet Connection",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 180323,
    "technicalServiceUid": "eef2fb0a-dac6-4d24-8000-64aa0918c145",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 180323",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Megaport Internet (v3) - Shut Down
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update Megaport Internet (v3) - Shut Down
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update Megaport Internet (v3) - Shut Down
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update Megaport Internet (v3) - Shut Down
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update Megaport Internet (v3) - Shut Down
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update Megaport Internet (v3) - Shut Down
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update Megaport Internet (v3) - Shut Down
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update Megaport Internet (v3) - Shut Down
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update VXC (v3)

**Request**

```json
{
  "shutdown": false
}
```

**Response**

```json
{
  "data": {
    "aLocation": null,
    "aLocationId": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bLocation": null,
    "bLocationId": null,
    "bgpShutdownDefault": false,
    "billableId": 69751,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1605048425572,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1605048397911,
    "createdBy": "52a26471-94de-4d32-b89e-0cd5d26c1f65",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated Name for VXC LA to Bay Area",
    "nonPayerCompanyId": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1605048397012,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated Name for VXC LA to Bay Area",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 70670,
    "technicalServiceUid": "8d360672-7aff-42b2-be6d-ce58a2927459",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "ZONE",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 70670",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = { "shutdown": False }
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"shutdown":false}'
};

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

```go Update VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"shutdown\": false\n}")

	req, _ := http.NewRequest("PUT", 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 Update VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"shutdown\": false\n}"

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

```java Update VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"shutdown\": false\n}")
  .asString();
```

```php Update VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "shutdown": false
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"shutdown\": false\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = ["shutdown": false] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update VXC Term (v3)

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 176637,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1705363994198,
    "contractStartDate": null,
    "contractTermMonths": 12,
    "createDate": 1705363982698,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "USA",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated Name for VXC with term",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 500,
    "rateType": "MONTHLY",
    "requestedDate": 1705363982677,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated Name for VXC with term",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 184834,
    "technicalServiceUid": "31d5500e-d4f8-41df-b3e7-40df975511c4",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "INTERZONE",
    "vxcPermitted": true
  },
  "message": "VXC 184834 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC Term (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update VXC Term (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update VXC Term (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update VXC Term (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update VXC Term (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update VXC Term (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update VXC Term (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update VXC Term (v3)
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update VXC for MCR (v3) - Rate limit and tags

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 233013,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1747110355842,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1747110353053,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "crossConnectRequested": false,
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated MCR VXC name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningStatus": "LIVE",
    "rateLimit": 10000,
    "rateType": "MONTHLY",
    "requestedDate": 1747110353041,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated MCR VXC name",
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 241182,
    "technicalServiceUid": "5897e5a5-f310-454d-85ad-9a806e9d1ecf",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "VXC 241182 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC for MCR (v3) - Rate limit and tags
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update VXC for MCR (v3) - Rate limit and tags
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update VXC for MCR (v3) - Rate limit and tags
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update VXC for MCR (v3) - Rate limit and tags
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update VXC for MCR (v3) - Rate limit and tags
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update VXC for MCR (v3) - Rate limit and tags
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update VXC for MCR (v3) - Rate limit and tags
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update VXC for MCR (v3) - Rate limit and tags
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update VXC for MCR (v3) - Various changes

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 233950,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1747628465099,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "costCentre": "1257883555",
    "createDate": 1747628441420,
    "createdBy": "f39b8983-256e-4643-adec-9f0b5da09ab7",
    "crossConnectRequested": false,
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Updated MCR VXC Name",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningStatus": "LIVE",
    "rateLimit": 10000,
    "rateType": "MONTHLY",
    "requestedDate": 1747628441394,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Updated MCR VXC Name",
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 242122,
    "technicalServiceUid": "3ec1a475-10e3-41ac-b279-e5848693dc5c",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "INTERZONE",
    "vxcPermitted": true
  },
  "message": "VXC 242122 ha sido actualizado",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC for MCR (v3) - Various changes
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

response = requests.put(url)

print(response.json())
```

```javascript Update VXC for MCR (v3) - Various changes
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {method: 'PUT'};

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

```go Update VXC for MCR (v3) - Various changes
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

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

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

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

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

}
```

```ruby Update VXC for MCR (v3) - Various changes
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

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

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

```java Update VXC for MCR (v3) - Various changes
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .asString();
```

```php Update VXC for MCR (v3) - Various changes
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid');

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

```csharp Update VXC for MCR (v3) - Various changes
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
IRestResponse response = client.Execute(request);
```

```swift Update VXC for MCR (v3) - Various changes
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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

### Update Alibaba VXC (v3)

**Request**

```json
{
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}
```

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Alibaba VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndVlan": 2727,
    "costCentre": "Service Level Reference",
    "name": "Updated VXC name",
    "rateLimit": 500,
    "term": 12
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Alibaba VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndVlan":2727,"costCentre":"Service Level Reference","name":"Updated VXC name","rateLimit":500,"term":12}'
};

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

```go Update Alibaba VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")

	req, _ := http.NewRequest("PUT", 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 Update Alibaba VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}"

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

```java Update Alibaba VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")
  .asString();
```

```php Update Alibaba VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Alibaba VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Alibaba VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Oracle VXC (v3)

**Request**

```json
{
  "aEndVlan": 4,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}
```

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Oracle VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndVlan": 4,
    "costCentre": "Service level reference",
    "name": "Updated VXC name",
    "rateLimit": 500,
    "term": 12
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Oracle VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndVlan":4,"costCentre":"Service level reference","name":"Updated VXC name","rateLimit":500,"term":12}'
};

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

```go Update Oracle VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndVlan\": 4,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")

	req, _ := http.NewRequest("PUT", 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 Update Oracle VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndVlan\": 4,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}"

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

```java Update Oracle VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndVlan\": 4,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")
  .asString();
```

```php Update Oracle VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndVlan": 4,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Oracle VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndVlan\": 4,\n  \"costCentre\": \"Service level reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Oracle VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndVlan": 4,
  "costCentre": "Service level reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update Salesforce VXC (v3)

**Request**

```json
{
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}
```

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update Salesforce VXC (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndVlan": 2727,
    "costCentre": "Service Level Reference",
    "name": "Updated VXC name",
    "rateLimit": 500,
    "term": 12
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update Salesforce VXC (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndVlan":2727,"costCentre":"Service Level Reference","name":"Updated VXC name","rateLimit":500,"term":12}'
};

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

```go Update Salesforce VXC (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")

	req, _ := http.NewRequest("PUT", 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 Update Salesforce VXC (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}"

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

```java Update Salesforce VXC (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")
  .asString();
```

```php Update Salesforce VXC (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update Salesforce VXC (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndVlan\": 2727,\n  \"costCentre\": \"Service Level Reference\",\n  \"name\": \"Updated VXC name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update Salesforce VXC (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndVlan": 2727,
  "costCentre": "Service Level Reference",
  "name": "Updated VXC name",
  "rateLimit": 500,
  "term": 12
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update VXC for MCR (v3)

**Request**

```json
{
  "costCentre": "1257883555",
  "name": "Updated MCR VXC Name",
  "rateLimit": 10000,
  "term": 36,
  "ipMtu": 5000,
  "resourceTags": [
    {
      "key": "stringykey2",
      "value": "value2"
    },
    {
      "key": "stringykey3",
      "value": "value3"
    }
  ]
}
```

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC for MCR (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "costCentre": "1257883555",
    "name": "Updated MCR VXC Name",
    "rateLimit": 10000,
    "term": 36,
    "ipMtu": 5000,
    "resourceTags": [
        {
            "key": "stringykey2",
            "value": "value2"
        },
        {
            "key": "stringykey3",
            "value": "value3"
        }
    ]
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update VXC for MCR (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"costCentre":"1257883555","name":"Updated MCR VXC Name","rateLimit":10000,"term":36,"ipMtu":5000,"resourceTags":[{"key":"stringykey2","value":"value2"},{"key":"stringykey3","value":"value3"}]}'
};

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

```go Update VXC for MCR (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"costCentre\": \"1257883555\",\n  \"name\": \"Updated MCR VXC Name\",\n  \"rateLimit\": 10000,\n  \"term\": 36,\n  \"ipMtu\": 5000,\n  \"resourceTags\": [\n    {\n      \"key\": \"stringykey2\",\n      \"value\": \"value2\"\n    },\n    {\n      \"key\": \"stringykey3\",\n      \"value\": \"value3\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("PUT", 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 Update VXC for MCR (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"costCentre\": \"1257883555\",\n  \"name\": \"Updated MCR VXC Name\",\n  \"rateLimit\": 10000,\n  \"term\": 36,\n  \"ipMtu\": 5000,\n  \"resourceTags\": [\n    {\n      \"key\": \"stringykey2\",\n      \"value\": \"value2\"\n    },\n    {\n      \"key\": \"stringykey3\",\n      \"value\": \"value3\"\n    }\n  ]\n}"

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

```java Update VXC for MCR (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"costCentre\": \"1257883555\",\n  \"name\": \"Updated MCR VXC Name\",\n  \"rateLimit\": 10000,\n  \"term\": 36,\n  \"ipMtu\": 5000,\n  \"resourceTags\": [\n    {\n      \"key\": \"stringykey2\",\n      \"value\": \"value2\"\n    },\n    {\n      \"key\": \"stringykey3\",\n      \"value\": \"value3\"\n    }\n  ]\n}")
  .asString();
```

```php Update VXC for MCR (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "costCentre": "1257883555",
  "name": "Updated MCR VXC Name",
  "rateLimit": 10000,
  "term": 36,
  "ipMtu": 5000,
  "resourceTags": [
    {
      "key": "stringykey2",
      "value": "value2"
    },
    {
      "key": "stringykey3",
      "value": "value3"
    }
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update VXC for MCR (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"costCentre\": \"1257883555\",\n  \"name\": \"Updated MCR VXC Name\",\n  \"rateLimit\": 10000,\n  \"term\": 36,\n  \"ipMtu\": 5000,\n  \"resourceTags\": [\n    {\n      \"key\": \"stringykey2\",\n      \"value\": \"value2\"\n    },\n    {\n      \"key\": \"stringykey3\",\n      \"value\": \"value3\"\n    }\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update VXC for MCR (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "costCentre": "1257883555",
  "name": "Updated MCR VXC Name",
  "rateLimit": 10000,
  "term": 36,
  "ipMtu": 5000,
  "resourceTags": [
    [
      "key": "stringykey2",
      "value": "value2"
    ],
    [
      "key": "stringykey3",
      "value": "value3"
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```

### Update VXC for MVE (v3)

**Request**

```json
{
  "aEndInnerVlan": 14,
  "aEndVlan": 121,
  "bEndInnerVlan": 14,
  "costCentre": "New reference for invoice",
  "name": "Updated name",
  "rateLimit": 500,
  "term": 12
}
```

**Response**

```json
{
  "data": {
    "aCountry": null,
    "aLocation": null,
    "aLocationId": null,
    "aMetro": null,
    "accountManager": null,
    "adminContactId": null,
    "adminContactName": null,
    "adminLocked": false,
    "aggregationId": null,
    "attributeTags": {},
    "attributes": [],
    "bCountry": null,
    "bLocation": null,
    "bLocationId": null,
    "bMetro": null,
    "bgpShutdownDefault": false,
    "billableId": 169066,
    "billableUsageAlgorithm": null,
    "billingContactId": null,
    "billingContactName": null,
    "buyoutPort": null,
    "companyId": 1153,
    "companyName": "Megaport Lab",
    "components": [],
    "configuredDate": 1698107963708,
    "contractStartDate": null,
    "contractTermMonths": 1,
    "createDate": 1698107955891,
    "createdBy": "2c2beb4a-53d0-47ed-9072-06f13a425502",
    "currentEstimatedDelivery": null,
    "errorMessage": null,
    "failedReason": null,
    "inAdvanceBillingStatus": null,
    "intercapPath": "",
    "lagId": null,
    "lagPrimary": false,
    "locked": false,
    "market": "Australia",
    "marketplaceVisibility": true,
    "maximumSpeed": null,
    "minimumSpeed": null,
    "name": "Move VXCBNE1 to PORTBNE3",
    "nonPayerCompanyId": null,
    "originDomain": null,
    "payerCompanyId": null,
    "productType": "VXC",
    "promptUid": null,
    "provisioningItems": [],
    "provisioningStatus": "LIVE",
    "rateLimit": 1000,
    "rateType": "MONTHLY",
    "requestedDate": 1698107955875,
    "salesId": null,
    "salesName": null,
    "secondaryName": null,
    "serviceName": "Move VXCBNE1 to PORTBNE3",
    "tags": [],
    "technicalContactId": null,
    "technicalContactName": null,
    "technicalServiceId": 177224,
    "technicalServiceUid": "4dfe983f-8f48-4e8f-b681-2a194d886182",
    "terminationDate": null,
    "trialAgreement": false,
    "virtual": false,
    "vxcAutoApproval": false,
    "vxcDistanceBand": "METRO",
    "vxcPermitted": true
  },
  "message": "Se ha actualizado VXC 177224",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python Update VXC for MVE (v3)
import requests

url = "https://api.megaport.com/v3/product/vxc/productUid"

payload = {
    "aEndInnerVlan": 14,
    "aEndVlan": 121,
    "bEndInnerVlan": 14,
    "costCentre": "New reference for invoice",
    "name": "Updated name",
    "rateLimit": 500,
    "term": 12
}
headers = {"Content-Type": "application/json"}

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

print(response.json())
```

```javascript Update VXC for MVE (v3)
const url = 'https://api.megaport.com/v3/product/vxc/productUid';
const options = {
  method: 'PUT',
  headers: {'Content-Type': 'application/json'},
  body: '{"aEndInnerVlan":14,"aEndVlan":121,"bEndInnerVlan":14,"costCentre":"New reference for invoice","name":"Updated name","rateLimit":500,"term":12}'
};

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

```go Update VXC for MVE (v3)
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/vxc/productUid"

	payload := strings.NewReader("{\n  \"aEndInnerVlan\": 14,\n  \"aEndVlan\": 121,\n  \"bEndInnerVlan\": 14,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")

	req, _ := http.NewRequest("PUT", 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 Update VXC for MVE (v3)
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/vxc/productUid")

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

request = Net::HTTP::Put.new(url)
request["Content-Type"] = 'application/json'
request.body = "{\n  \"aEndInnerVlan\": 14,\n  \"aEndVlan\": 121,\n  \"bEndInnerVlan\": 14,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}"

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

```java Update VXC for MVE (v3)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://api.megaport.com/v3/product/vxc/productUid")
  .header("Content-Type", "application/json")
  .body("{\n  \"aEndInnerVlan\": 14,\n  \"aEndVlan\": 121,\n  \"bEndInnerVlan\": 14,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}")
  .asString();
```

```php Update VXC for MVE (v3)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://api.megaport.com/v3/product/vxc/productUid', [
  'body' => '{
  "aEndInnerVlan": 14,
  "aEndVlan": 121,
  "bEndInnerVlan": 14,
  "costCentre": "New reference for invoice",
  "name": "Updated name",
  "rateLimit": 500,
  "term": 12
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Update VXC for MVE (v3)
using RestSharp;

var client = new RestClient("https://api.megaport.com/v3/product/vxc/productUid");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"aEndInnerVlan\": 14,\n  \"aEndVlan\": 121,\n  \"bEndInnerVlan\": 14,\n  \"costCentre\": \"New reference for invoice\",\n  \"name\": \"Updated name\",\n  \"rateLimit\": 500,\n  \"term\": 12\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Update VXC for MVE (v3)
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [
  "aEndInnerVlan": 14,
  "aEndVlan": 121,
  "bEndInnerVlan": 14,
  "costCentre": "New reference for invoice",
  "name": "Updated name",
  "rateLimit": 500,
  "term": 12
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.megaport.com/v3/product/vxc/productUid")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```