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

# Update VXC (v3)

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

Updates editable information for a VXC.

The `productUid` identifies the VXC.

**Tip:** Use the `/v2/product` endpoint to determine the `productUid`.

The changes are defined in the Body of the request. Only include the parameters that you want to update. For a VXC, you can update the following parameters:

- `name` - Customer name for the connection - this name appears in the Portal.
    
- `rateLimit` - A new speed for the connection.
    
- `aEndVlan` - A unique VLAN ID for this connection. Values can range from 2 to 4093. If this value is 0, the system allocates a valid VLAN.
    
- `bEndVlan` - A unique VLAN ID for this connection. Values can range from 2 to 4093. If this value is 0, the system allocates a valid VLAN.
    
- `term` - Set up a term for this VXC. Note that there are rules for terms. See **VXC Terms** below for more information.
    
- `costCentre` - A customer reference number to be included in billing information and invoices
    
- `aEndProductUid` - When moving a VXC, this is the new A-End for the connection.
    
- `bEndProductUid` - When moving a VXC, this is the new B-End for the connection.
    
- `aVnicIndex` - When moving a VXC for an MVE, this is the new A-End vNIC for the connection.
    
- `bVnicIndex` - When moving a VXC for an MVE, this is the new B-End vNIC for the connection.
    
- `isApproved` - Define whether the VXC is approved or rejected via the Megaport Marketplace. Set to `true` (Approved) or `false` (Rejected).  
    **Note:** Valid only if there is an order pending approval (either new marketplace request or speed change). If there are no orders pending approval and `isApproved` is sent in the request, the API will return an error.
    
- `shutdown` - Temporarily shut down and re-enable the VXC. Valid values are `true` (shut down) and `false` (enabled). If not provided, it defaults to `false` (enabled).
    

For more information, see [Changing a VXC Configuration with the API](https://docs.megaport.com/api/api-vxc-change/).

**Note:** You can update a product only when its provisioning status is `CONFIGURED` or `LIVE`.

#### VXC Terms

You can update the term of the VXC by updating the `term` field.

The following rules apply to updating VXC terms:

- If validation fails, the term defaults to No Minimum Term, `contractTermMonths:1`.
    
- The speed cannot be changed when the VXC is on term.
    
- You can change the speed only if the VXC is on No Minimum Term, if the term has expired, or if reterming to a longer term.
    
- If you are updating a VXC on term, you can only reterm to a higher term. If you need to change the speed, you can only change it to a higher rate limit.
    
- If you are updating an expired VXC on term, any term and/or speed can be selected.
    
- You cannot change a VXC from a term (12/24/36 month) to month-to-month/No Minimum Term unless the term has expired.
    
- You cannot reterm a VXC if the service is on a non-standard price.
    
- You _can_ move or shut down VXCs on term.
    

#### Move VXC

You can move a VXC by updating the A-End or B-End or both, using the fields `aEndProductUid` and `bEndProductUid`. When moving a VXC for an MVE, you can also select the vNICs at the A-End and B-End using the fields `aVnicIndex` and `bVnicIndex`.

The following rules determine where and how you can move a VXC:

- The new Port can be in a different location but must be in the **same metro area**.
    
- The new Port must be of the same type. For example, MEGAPORT to MEGAPORT, MCR to MCR, or MVE to MVE.
    
- The configured speed of each VXC must be no greater than the speed of the destination Port. If downgrading, it might be necessary for you to lower the speed of the VXC before requesting the move.
    
- There must not be an IP address or VLAN conflict. The updated services are checked as if a new service is being ordered. For example, an untagged VLAN can't be moved to a service that already has an untagged VLAN.
    
- The services being moved must have different VLAN IDs from any services already on the destination.
    

If the VXC move is invalid, the move will fail.

For more information, see [Moving VXCs](https://docs.megaport.com/connections/move-vxc/) and [Moving a VXC and IX with the API](https://docs.megaport.com/api/api-vxc-move/).

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

## Servers

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

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

Update VXC (v3) / Move VXC (v3) / Move VXC for MVE - Update vNICs on Both Ends (v3) / Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3) / Shut Down VXC (v3) / Re-enable VXC (v3) / Update VXC Term (v3) / Move VXC (v3) / Move VXC for MVE - Change B-End to Connect to MVE with Multiple vNICs (v3) / Update VXC (v3) / Update VXC Term (v3) / Move VXC for MVE - Update vNICs on Both Ends (v3) / Shut Down VXC (v3) / Re-enable VXC (v3) / Update Megaport Internet (v3) / Update Megaport Internet (v3) - 12 Month Contract Term / Update Megaport Internet (v3) - 24 Month Contract Term / Update Megaport Internet (v3) - Move / Update Megaport Internet (v3) - Shut Down / Update Megaport Internet (v3) - Re-enable / Update Megaport Internet (v3) / Update Megaport Internet (v3) - 12 Month Contract Term / Update Megaport Internet (v3) - Re-enable / Update Megaport Internet (v3) - Shut Down / Update Megaport Internet (v3) - Move / Update Megaport Internet (v3) - 24 Month Contract Term / Update AWS Hosted VIF VXC (v3) / Update AWS Hosted VIF VXC (v3) / Update Azure VXC (v3) / Update Azure VXC (v3) / Update AWS Hosted VIF VXC (v3) / Update AWS Hosted VIF VXC (v3) / Update Azure VXC (v3) / Update Azure VXC (v3) / Update AWS Hosted VIF VXC (v3) / Update AWS Hosted VIF VXC (v3) / Update Azure VXC (v3) / Update Azure VXC (v3) / Update Google VXC (v3) / Update Google VXC (v3) / Update VXC for MCR (v3) - Rate limit and tags / Update VXC for MCR (v3) - Various changes / Update VXC for MCR (v3) - Rate limit and tags / Update VXC for MCR (v3) - Various changes / Update Megaport Internet (v3) / Update Megaport Internet (v3) - 12 Month Contract Term / Update Megaport Internet (v3) / Update Megaport Internet (v3) - 12 Month Contract Term

- `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": "VXC 177224 has been updated",
  "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 has been updated",
  "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 has been updated",
  "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": "VXC 166698 has been updated",
  "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": "VXC 166698 has been updated",
  "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": "VXC 155724 has been updated",
  "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 has been updated",
  "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 has been updated",
  "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": "VXC 70670 has been updated",
  "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": "VXC 182960 has been updated",
  "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": "VXC 182965 has been updated",
  "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": "VXC 180323 has been updated",
  "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": "VXC 180323 has been updated",
  "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": "VXC 180323 has been updated",
  "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": "VXC 70670 has been updated",
  "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 has been updated",
  "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 has been updated",
  "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 has been updated",
  "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": "VXC 177224 has been updated",
  "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": "VXC 177224 has been updated",
  "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": "VXC 177224 has been updated",
  "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": "VXC 177224 has been updated",
  "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": "VXC 177224 has been updated",
  "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()
```