Name: Vertex Key AI – Claude, GPT-5 & Gemini | Free · $1/mo | API.market
Brand: vertex-key
SKU: api-vertex-key-api
Availability: InStock
Author: API Market

Minh Vũ Đức

# Vertex Key AI API

OpenAI-compatible API Gateway providing access to premium AI models from Claude & GPT-5 families. Multi-provider routing with automatic failover and load balancing.

## 🚀 Available Models

### ⚡ Flash Tier — Claude Premium
| Model | Context | Features |
|-------|---------|----------|
| flash/claude-opus-4-6 | 200K | Chat, Tool Use |
| flash/claude-sonnet-4-6 | 200K | Chat, Tool Use |

Best for: High-quality Claude responses with fast speed.

### 💎 Pro Tier — GPT-5 Premium
| Model | Context | Features |
|-------|---------|----------|
| pro/gpt-5.2-high | 272K | Chat, Vision, 128K Output |
| pro/gpt-5.2-low | 272K | Chat, Vision, Budget |

Best for: GPT-5 tasks with Vision support, large context and high output.


### 🌟 Lite Tier — Multi-Model
| Model | Context | Features |
|-------|---------|----------|
| lite/claude-opus-4-6 | 200K | Chat |
| lite/claude-sonnet-4-6 | 200K | Chat |
| lite/claude-sonnet-4-5 | 200K | Chat |
| lite/claude-haiku-4-5 | 200K | Chat, Fast |
| lite/gpt-5.2 | 128K | Chat |
| lite/gpt-5.1 | 128K | Chat |
| lite/gpt-5 | 128K | Chat |

Best for: Cost-effective access to multiple models.

## ✨ Supported Models and Pricing

### Flash ⚡ — Claude Premium (SupperAPI)

| Model | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) |
|-------|:--------------------------:|:---------------------------:|
| flash/claude-opus-4-6 | $5.00 | $25.00 |
| flash/claude-sonnet-4-6 | $3.00 | $15.00 |

### Pro 💎 — GPT-5 Series (RightCodes)

| Model | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) |
|-------|:--------------------------:|:---------------------------:|
| pro/gpt-5 | $1.25 | $10.00 |
| pro/gpt-5-codex | $1.25 | $10.00 |
| pro/gpt-5-codex-mini | $0.50 | $2.50 |
| pro/gpt-5.1 | $1.50 | $12.00 |
| pro/gpt-5.1-codex | $1.50 | $14.00 |
| pro/gpt-5.1-codex-max | $1.50 | $14.00 |
| pro/gpt-5.1-codex-mini | $0.50 | $2.50 |
| pro/gpt-5.2 | $1.75 | $14.00 |
| pro/gpt-5.2-low | $1.00 | $8.00 |
| pro/gpt-5.2-high | $1.75 | $14.00 |
| pro/gpt-5.3-codex | $2.50 | $20.00 |
| pro/gpt-5.3-codex-low | $1.50 | $12.00 |
| pro/gpt-5.3-codex-xhigh | $3.00 | $24.00 |

### Lite 💡 — Multi-Model (Augment)

| Model | Input Cost (per 1M tokens) | Output Cost (per 1M tokens) |
|-------|:--------------------------:|:---------------------------:|
| lite/claude-haiku-4-5 | $0.80 | $4.00 |
| lite/claude-sonnet-4 | $3.00 | $15.00 |
| lite/claude-sonnet-4-5 | $3.00 | $15.00 |
| lite/claude-sonnet-4-6 | $3.00 | $15.00 |
| lite/claude-opus-4-5 | $5.00 | $25.00 |
| lite/claude-opus-4-6 | $5.00 | $25.00 |
| lite/gpt-5-2 | $2.00 | $8.00 |
| lite/gpt-5 | $5.00 | $15.00 |
| lite/gpt-5-1 | $5.00 | $15.00 |


## ✨ Key Features

- **OpenAI Compatible** — Drop-in replacement, works with any OpenAI SDK
- **Streaming** — Real-time Server-Sent Events (SSE)
- **Tool Use** — Function calling support on Flash tier
- **Auto Failover** — Automatic fallback between providers
- **Low Latency** — Optimized global routing
- **Simple Auth** — Bearer token authentication

## 📡 Quick Start

**cURL Example:**

```bash
curl -X POST "https://prod.api.market/api/v1/vertex-key/api/chat/completions" \
   -H "x-api-market-key: YOUR_API_MARKET_KEY"\
  -H "Content-Type: application/json" \
  -d '{
    "model": "flash/claude-sonnet-4-6",
    "messages": [{"role": "user", "content": "Hello!"}],
    "max_tokens": 1024
  }'
```

**Response (Success - JSON):**

```json
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1698765432,
  "model": "flash/claude-sonnet-4-6",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! I am doing well, thank you for asking. How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 30,
    "total_tokens": 50
  }
}
```

**Response (Success - Streaming - text/event-stream):**

```text
data: {"id": "chatcmpl-stream-123", "object": "chat.completion.chunk", "created": 1698765432, "model": "flash/claude-sonnet-4-6", "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": null}]}

data: {"id": "chatcmpl-stream-123", "object": "chat.completion.chunk", "created": 1698765432, "model": "flash/claude-sonnet-4-6", "choices": [{"index": 0, "delta": {"content": "AI"}, "finish_reason": null}]}

data: {"id": "chatcmpl-stream-123", "object": "chat.completion.chunk", "created": 1698765432, "model": "flash/claude-sonnet-4-6", "choices": [{"index": 0, "delta": {"content": " is"}, "finish_reason": null}]}

... (more data lines)

data: {"id": "chatcmpl-stream-123", "object": "chat.completion.chunk", "created": 1698765432, "model": "flash/claude-sonnet-4-6", "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}]}

data: [DONE]
```

#### 2. List Available Models

**GET /models**

Returns a list of all available AI models with pricing, features, and context length information.

**cURL Example:**

```bash
curl -X GET "https://prod.api.market/api/v1/vertex-key/api/models" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response (Success):**

```json
{
  "object": "list",
  "data": [
    {
      "id": "flash/claude-opus-4-6",
      "object": "model",
      "owned_by": "anthropic"
    },
    {
      "id": "flash/claude-sonnet-4-6",
      "object": "model",
      "owned_by": "anthropic"
    },
    {
      "id": "pro/gpt-5.2-high",
      "object": "model",
      "owned_by": "rightcodes"
    },
    ...
  ]
}
```

## Status Codes

*   **200 OK:** Request successful.
*   **400 Bad Request:** Invalid parameters or malformed request.  Check your request body and parameters against the API documentation.
*   **401 Unauthorized:** Missing or invalid API key. Ensure your API key is correctly included in the `x-api-market-key` header.
*   **402 Insufficient Balance:** Account has insufficient balance. Top up your account to continue using the API.
*   **429 Too Many Requests:** Rate limit exceeded.  Implement rate limiting in your application to avoid exceeding the API's rate limits.
*   **503 Service Unavailable:** No upstream provider available. This indicates a temporary issue with the underlying AI model providers. Retry the request after a short delay.

## Rate Limits

Please refer to your API.market dashboard for specific rate limits applied to your account.  Exceeding the rate limit will result in a `429 Too Many Requests` error.  Implement retry logic with exponential backoff to handle rate limiting gracefully.

## Error Handling

The API returns error responses in JSON format with an `error` object. The `error` object contains a `message`, `type`, and `code` field to help diagnose the issue.

**Example Error Response:**

```json
{
  "error": {
    "message": "The parameter 'model' is required",
    "type": "invalid_request_error",
    "code": "missing_parameter"
  }
}
```

**Common Errors and Resolutions:**

*   `missing_parameter`: A required parameter is missing from the request. Provide the missing parameter.
*   `invalid_parameter`: A parameter has an invalid value. Check the parameter value against the API documentation.
*   `invalid_api_key`: The API key is invalid. Verify your API key.
*   `rate_limit_exceeded`: The rate limit has been exceeded. Implement retry logic with exponential backoff.
*   `model_not_found`: The specified model ID does not exist. Check the list of available models and use a valid model ID.

For transient errors (e.g., `rate_limit_exceeded`, `service_unavailable`), it is recommended to implement a retry strategy with exponential backoff. This involves retrying the request after a delay, with the delay increasing with each subsequent retry. This helps to avoid overwhelming the API and increases the chances of a successful request.

## Implementation Guide

### Example Code

#### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/vertex-key/api";

async function createChatCompletion(model, messages) {
  try {
    const response = await fetch(`${baseUrl}/chat/completions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${apiKey}`
      },
      body: JSON.stringify({
        model: model,
        messages: messages,
        max_tokens: 1024
      })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const data = await response.json();
    return data;

  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

// Example usage
async function main() {
  try {
    const response = await createChatCompletion("flash/claude-sonnet-4-6", [
      { role: "user", content: "Hello, how are you?" }
    ]);
    console.log("Response:", response);
  } catch (error) {
    console.error("Failed to get completion:", error);
  }
}

main();
```

#### Python

```python
import requests
import json

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/vertex-key/api"

def create_chat_completion(model, messages):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {API_KEY}"
    }
    data = {
        "model": model,
        "messages": messages,
        "max_tokens": 1024
    }

    response = requests.post(f"{BASE_URL}/chat/completions", headers=headers, data=json.dumps(data))

    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return response.json()

# Example usage
try:
    response = create_chat_completion("flash/claude-sonnet-4-6", [
        {"role": "user", "content": "Hello, how are you?"}
    ])
    print("Response:", response)
except Exception as e:
    print(f"Failed to get completion: {e}")
```



### Performance Optimization

*   **Select the Right Model:** Choose the model that best fits your needs.  Smaller models are faster and cheaper, while larger models are more accurate.
*   **Optimize Input:**  Minimize the size of your input prompts.  The fewer tokens you send, the faster the API will respond and the less it will cost.
*   **Use Streaming:** For long-running tasks, use streaming to get results as they become available.  This can improve perceived performance and reduce the time to first byte.
*   **Implement Caching:** Cache responses to avoid making redundant API calls.
*   **Monitor Usage:** Track your API usage and identify areas for optimization.

## FAQ

**Q: What models are supported?**

A:  The API supports a variety of models from Claude, GPT-5, and Gemini families. See the `/models` endpoint for a complete list.

**Q: How do I handle rate limiting?**

A: Implement retry logic with exponential backoff to avoid exceeding the API's rate limits.

**Q: What is the difference between the Flash, Pro, and Lite tiers?**

A: The Flash tier offers premium Claude models, the Pro tier offers GPT-5 models, and the Lite tier offers a selection of multiple models for cost-effectiveness.

**Q: How can I use vision capabilities?**

A: Include image URLs or base64 encoded images in the content of your messages.  See the "Vision Example" in the API Documentation section.

**Q: Is streaming supported?**

A: Yes, streaming is supported. Set the `stream` parameter to `true` in your request body.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@api.market.
```

OpenAI-compatible API for 60+ models like Claude & GPT-5. With vision & tool use. Free 10000 calls/mo, from $1/mo. Start free on API.market.

Vertex Key AI – Claude, GPT-5 & Gemini | Free · $1/mo | API.market

Free

vertex-key

Start

Basic

Ultra

Mega

Elite

Prime

OpenAI-compatible API with 60+ models: Claude Opus/Sonnet, GPT-5, Gemini. Streaming, Vision, Tool Use. Multi-provider failover.


Vertex Key AI API