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

# Tamaños de MVE Disponibles (v3)

GET https://api.megaport.com/v3/product/mve/variants

Devuelve una lista de los tamaños de MVE disponibles actualmente y los detalles de cada tamaño.

El tamaño de la instancia determina las capacidades del MVE, como la cantidad de conexiones concurrentes que puede admitir.

Los tamaños de cómputo son 2/8, 4/16, 8/32, 16/64 y 32/128, donde el primer número es el recuento de CPU y el segundo número es los GB de RAM disponibles. Cada tamaño tiene 4 GB de RAM por cada vCPU asignada.

Al elegir un tamaño de instancia MVE, tenga en cuenta estos elementos:

- Cualquier aumento en la carga del flujo de datos de red puede degradar el rendimiento. Por ejemplo, establecer túneles seguros con IPsec, agregar direccionamiento de ruta de tráfico o usar inspección de paquetes profunda (DPI) puede afectar la velocidad de rendimiento máxima.
    
- Planes futuros para escalar la red.
    

Para verificar qué tamaños de instancia MVE están disponibles para su implementación, use el Portal de Megaport durante el proceso de configuración de MVE. La disponibilidad del tamaño de instancia depende tanto del proveedor seleccionado como de la ubicación de implementación, y puede variar en consecuencia. El Portal de Megaport muestra los tamaños disponibles para el proveedor y la ubicación seleccionados.

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

## Servers

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

## Response

### 200

Tamaños de MVE Disponibles (v3) / Tamaños de MVE Disponibles (v3)

- `data` (list of V3ProductMveVariantsGetResponsesContentApplicationJsonSchemaDataItems, optional)
- `message` (string, optional)
- `terms` (string, optional)

## Types

### V3ProductMveVariantsGetResponsesContentApplicationJsonSchemaDataItems

- `cpuCoreCount` (double, optional)
- `label` (string, optional)
- `ramGB` (double, optional)
- `size` (string, optional)

## Examples

**Response**

```json
{
  "data": [
    {
      "cpuCoreCount": 2,
      "label": "MVE 2/8",
      "ramGB": 8,
      "size": "SMALL"
    },
    {
      "cpuCoreCount": 4,
      "label": "MVE 4/16",
      "ramGB": 16,
      "size": "MEDIUM"
    },
    {
      "cpuCoreCount": 8,
      "label": "MVE 8/32",
      "ramGB": 32,
      "size": "LARGE"
    },
    {
      "cpuCoreCount": 16,
      "label": "MVE 16/64",
      "ramGB": 64,
      "size": "X_LARGE_16"
    },
    {
      "cpuCoreCount": 32,
      "label": "MVE 32/128",
      "ramGB": 128,
      "size": "X_LARGE_32"
    }
  ],
  "message": "Tamaños de MVE compatibles actuales",
  "terms": "This data is subject to the Acceptable Use Policy https://www.megaport.com/legal/acceptable-use-policy"
}
```

**SDK Code**

```python
import requests

url = "https://api.megaport.com/v3/product/mve/variants"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://api.megaport.com/v3/product/mve/variants';
const options = {method: 'GET'};

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

```go
package main

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

func main() {

	url := "https://api.megaport.com/v3/product/mve/variants"

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

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

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

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

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.megaport.com/v3/product/mve/variants")

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

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

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.megaport.com/v3/product/mve/variants")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.megaport.com/v3/product/mve/variants');

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

```csharp
using RestSharp;

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

```swift
import Foundation

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

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