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

# GPT Responses

POST https://direct.beatapi.io/v1/responses
Content-Type: application/json

Call GPT-6.1 Sol, GPT-6 Astra, GPT-6 Sol and GPT-6 Luna through the OpenAI Responses API with a BeatAPI key.- One endpoint, `POST /v1/responses`, for every current GPT model. Change `model` to switch.
- The recommended format for new reasoning and tool-calling integrations.
- Text and image input, text output, streaming, function calling, structured outputs and configurable reasoning effort.
- Works with the OpenAI SDK: change the base URL and use a BeatAPI key. For an existing Chat Completions integration, see [Chat Completions](/text-api/gpt/chat-completions).Use `https://direct.beatapi.io` as the base URL for text requests: it is not subject to Cloudflare's 100-second limit, so a long non-streaming request is not cut off. `https://api.beatapi.io` also works and is the fallback if `direct.beatapi.io` is unreachable from your network. The key, models and prices are the same on both. Image and video APIs use `https://api.beatapi.io` only.POST/v1/responsesTry itOpens this endpoint in the API Explorer. Enter your BeatAPI API key and send: the call is real and is billed to your own balance.## ModelsSend one of these IDs as `model`. Each is a separate model; do not treat them as aliases of each other.| Model ID      | Context (tokens) | Max output (tokens) | Positioning                                                                                  | Input, USD per 1M tokens | Output, USD per 1M tokens | Notes                                                                      |
| ------------- | ---------------- | ------------------- | -------------------------------------------------------------------------------------------- | ------------------------ | ------------------------- | -------------------------------------------------------------------------- |
| `gpt-6.1-sol` | 1,050,000        | 128,000             | GPT-6.1 Sol for coding, computer use, and professional work. Use Responses for tool calling. | \$0.80                   | \$4.00                    | Reasoning effort `low` to `max`. Higher rate above 272K input tokens.      |
| `gpt-6-astra` | 1,000,000        | 128,000             | Most capable GPT model: complex reasoning, coding, computer use, research and document work  | \$4.00                   | \$20.00                   | Higher rate above 272K input tokens.                                       |
| `gpt-6-sol`   | 1,050,000        | 128,000             | Mid-tier GPT-6 model for everyday coding, research, and agentic work at a lower price        | \$0.80                   | \$4.00                    | A separate model from GPT-6.1 Sol and GPT-5.6 Sol.                         |
| `gpt-6-luna`  | 1,050,000        | 128,000             | Cost-efficient GPT-6 model for focused, high-volume tasks                                    | \$0.04                   | \$0.20                    | High-volume, focused tasks such as extraction, classification and routing. |- Prices are the base tier, discount already applied. A long-context tier, cached-input rates and cache writes are not in this table; see the [price table](https://beatapi.io/pricing).
- `—` means the catalogue does not publish the number.Older IDs of this family still work and are listed on [Legacy models](/text-api/legacy-models).## Quick startInstall the `openai` package on your server, keep the key in `BEATAPI_API_KEY`, and never put it in browser code. `output_text` is the SDK's shortcut for the answer text.Reasoning effort accepts `none`, `low`, `medium`, `high`, `xhigh` and `max` on the GPT-5.6 models; `gpt-6.1-sol` accepts `low` to `max`. Use `medium` as a balanced starting point, then evaluate one level lower and higher on your own workload. An HTTP 200 alone does not prove the answer satisfies your task: validate it in your application.```bash title="cURL"
curl --request POST \
  --url https://direct.beatapi.io/v1/responses \
  --header "Authorization: Bearer $BEATAPI_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
  "model": "gpt-6.1-sol",
  "input": "Design a resilient webhook retry strategy for a payments API.",
  "reasoning": {
    "effort": "medium"
  }
}'
``````python title="Python"
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["BEATAPI_API_KEY"], base_url="https://direct.beatapi.io/v1")
response = client.responses.create(
    model="gpt-6.1-sol",
    input="Design a resilient webhook retry strategy for a payments API.",
    reasoning={
      "effort": "medium"
    },
)
print(response.output_text)
``````javascript title="JavaScript"
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.BEATAPI_API_KEY, baseURL: "https://direct.beatapi.io/v1" });
const response = await client.responses.create({
  "model": "gpt-6.1-sol",
  "input": "Design a resilient webhook retry strategy for a payments API.",
  "reasoning": {
    "effort": "medium"
  }
});
console.log(response.output_text);
```## Endpoint and authentication`POST https://direct.beatapi.io/v1/responses`Authorization
string
Required`Bearer <BEATAPI_API_KEY>`. The key works with or without the `sk-` prefix.## Request parametersStandard OpenAI Responses fields are accepted. Request-format compatibility does not mean every provider-specific option or hosted tool is supported, so test the options you rely on.model
string
RequiredThe exact model ID.**Allowed values**: `gpt-6.1-sol`, `gpt-6-astra`, `gpt-6-sol`, `gpt-6-luna`- Older IDs that still work (`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`) are on [Legacy models](/text-api/legacy-models).
- Call `GET /v1/models` with your key to confirm which models are enabled for it.input
string | object[]
RequiredThe prompt: a string, or an array of input items for text and image input.- Image input is supported by all GPT models on this page.reasoning
object
OptionalReasoning settings. `reasoning.effort` chooses how much the model reasons before answering.**Allowed values**: `none`, `low`, `medium`, `high`, `xhigh`, `max`**Per model**- `gpt-6.1-sol`: `low`, `medium`, `high`, `xhigh` and `max`. `none` and `minimal` are not supported.
- `gpt-5.6-sol`: `none`, `low`, `medium`, `high`, `xhigh` and `max`.
- `gpt-5.6-terra`: `none`, `low`, `medium`, `high`, `xhigh` and `max`.
- `gpt-5.6-luna`: `none`, `low`, `medium`, `high`, `xhigh` and `max`.**Example**```json
{ "effort": "medium" }
```max_output_tokens
integer
OptionalUpper bound on the generated tokens.- The gateway accepts values up to 1,073,741,823; a larger value is `400 bad_request`.
- The gateway does not compare your value with the model's max output from the table above. Keep it at or below that number.
- The value is also used to estimate how much balance a request needs. A very large value can be refused with `402 insufficient_credits` even when the real output would be small. Set it to what you need.stream
boolean
OptionalDefault: falseReturn the answer as server-sent events. See the Streaming section below.**Default**: `false`tools
object[]
OptionalFunction tools the model may call. Responses is the recommended format for tool calls.text
object
OptionalOutput format settings, for example `text.format` for structured outputs.## ResponseA non-streaming call returns one JSON object. This is an abbreviated example.```json
{
  "id": "resp_example",
  "object": "response",
  "model": "gpt-6.1-sol",
  "status": "completed",
  "output": [
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "Retry with exponential backoff and jitter, and make every handler idempotent."
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 19,
    "output_tokens": 16,
    "total_tokens": 35
  }
}
```### Response fields| Field      | Type       | Description                                                                                             |
| ---------- | ---------- | ------------------------------------------------------------------------------------------------------- |
| `id`       | `string`   | The response ID. Log it, together with the request ID, for support and billing audits.                  |
| `model`    | `string`   | The model that answered.                                                                                |
| `status`   | `string`   | `completed` for a finished answer.                                                                      |
| `output[]` | `object[]` | Output items: messages, reasoning and tool calls. The SDK's `output_text` joins the text parts for you. |
| `usage`    | `object`   | Token counts. Calls are metered from actual token usage.                                                |## StreamingSet `"stream": true`. BeatAPI forwards the server-sent event stream without converting it, so event names and objects stay compatible with the OpenAI SDK.- The response is `text/event-stream`; without streaming it is `application/json`.
- A failure before the model is called is returned as a normal JSON error with an HTTP status, not as a stream event.
- Set explicit timeouts and reconnect a streamed response safely.```text
event: response.output_text.delta
data: {"type":"response.output_text.delta","delta":"Retry"}

event: response.output_text.delta
data: {"type":"response.output_text.delta","delta":" with backoff"}

event: response.completed
data: {"type":"response.completed","response":{"id":"resp_example","status":"completed"}}
```## Errors| Error or symptom                                         | Cause                                                                                                         | Fix                                                                     |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| `400` with a reasoning effort the model does not support | For example `none` on `gpt-6.1-sol`.                                                                          | Use a value the model supports; see `reasoning` above.                  |
| `402 insufficient_credits`                               | Balance below the price of the request, often because `max_output_tokens` is very large.                      | Top up, or lower `max_output_tokens`.                                   |
| `403 forbidden`                                          | The account is on free credit and the model is not on the free list, or the model is outside the key's group. | Top up, use a free model, or use a key whose group can reach the model. |
| `404 not_found`                                          | Unknown model ID, or not enabled for this key.                                                                | List the enabled models with `GET /v1/models`.                          |
| `429 rate_limit_exceeded`                                | Account or free-model limit reached.                                                                          | Wait `Retry-After`, then retry.                                         |### HTTP errors at a glanceAuthentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).| HTTP status | Code                                                       | What to do                                                                                   |
| ----------- | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| 400         | `bad_request`, `content_policy_violation`                  | Fix the request or the input; do not resend it unchanged.                                    |
| 401         | `missing_api_key`, `invalid_api_key`                       | Check the key. Do not retry.                                                                 |
| 402         | `insufficient_credits`                                     | Top up, or raise the key's limit. A very large `max_tokens` can trigger it.                  |
| 403         | `forbidden`                                                | The model is outside the key's group or IP allowlist, or free credit cannot call this model. |
| 404         | `not_found`                                                | Unknown model: list the enabled ones with `GET /v1/models`.                                  |
| 429         | `rate_limit_exceeded`                                      | Wait `Retry-After` or `retry_after_seconds`, then retry with backoff.                        |
| 500         | `internal_error`, `temporary_error`                        | Retry once or twice with backoff.                                                            |
| 503         | `model_unavailable`, `upstream_timeout`, `temporary_error` | Retry with backoff, or use another model.                                                    |Full code table and retry policy: [Errors](/errors#text-endpoints).## Notes- Claude models do not answer on `/v1/responses` (`400 bad_request`); call them on [Anthropic Messages](/text-api/claude/messages).
- Above 272K input tokens, `gpt-6.1-sol` and `gpt-6-astra` use a higher tier for the full request. See the [price table](https://beatapi.io/pricing) before budgeting a long-context workload.
- Keep API keys on trusted servers, log the response request ID, and retry only `429`, `500` and `503`.

Reference: https://docs.beatapi.io/api-reference/text-api/gpt-responses

## Authentication

- `Authorization` header (bearer token, required) — Send your API key as `Authorization: Bearer <BEATAPI_API_KEY>`.

## Servers

- `https://direct.beatapi.io` (Direct, default)
- `https://api.beatapi.io` (API)

## Request

### Body (application/json)

This endpoint expects an object.

- `model` (enum, required) — The exact model ID. Older IDs that still work (`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`) are on [Legacy models](/text-api/legacy-models). Call `GET /v1/models` with your key to confirm which models are enabled for it. `gpt-6.1-sol`, `gpt-6-astra`, `gpt-6-sol`, `gpt-6-luna`
  - Allowed values: `gpt-6.1-sol`, `gpt-6-astra`, `gpt-6-sol`, `gpt-6-luna`
- `input` (V1ResponsesPostRequestBodyContentApplicationJsonSchemaInput, required) — The prompt: a string, or an array of input items for text and image input. Image input is supported by all GPT models on this page.
- `reasoning` (V1ResponsesPostRequestBodyContentApplicationJsonSchemaReasoning, optional) — Reasoning settings. `reasoning.effort` chooses how much the model reasons before answering. `gpt-6.1-sol`: `low`, `medium`, `high`, `xhigh` and `max`. `none` and `minimal` are not supported. `gpt-5.6-sol`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `gpt-5.6-terra`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `gpt-5.6-luna`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `none`, `low`, `medium`, `high`, `xhigh`, `max`
- `max_output_tokens` (integer, optional) — Upper bound on the generated tokens. The gateway accepts values up to 1,073,741,823; a larger value is `400 bad_request`. The gateway does not compare your value with the model's max output from the table above. Keep it at or below that number. The value is also used to estimate how much balance a request needs. A very large value can be refused with `402 insufficient_credits` even when the real output would be small. Set it to what you need.
- `stream` (boolean, optional, default: false) — Return the answer as server-sent events. See the Streaming section below.
- `tools` (list of V1ResponsesPostRequestBodyContentApplicationJsonSchemaToolsItems, optional) — Function tools the model may call. Responses is the recommended format for tool calls.
- `text` (V1ResponsesPostRequestBodyContentApplicationJsonSchemaText, optional) — Output format settings, for example `text.format` for structured outputs.

## Response

### 200

A non-streaming call returns one JSON object. This is an abbreviated example.

- `id` (string, optional) — The response ID. Log it, together with the request ID, for support and billing audits.
- `model` (string, optional) — The model that answered.
- `status` (string, optional) — `completed` for a finished answer.
- `output` (list of V1ResponsesPostResponsesContentApplicationJsonSchemaOutputItems, optional) — Output items: messages, reasoning and tool calls. The SDK's `output_text` joins the text parts for you.
- `usage` (V1ResponsesPostResponsesContentApplicationJsonSchemaUsage, optional) — Token counts. Calls are metered from actual token usage.

## Errors

### 400 Bad Request Error

`bad_request`, `content_policy_violation` Fix the request or the input; do not resend it unchanged. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 401 Unauthorized Error

`missing_api_key`, `invalid_api_key` Check the key. Do not retry. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 402 Payment Required Error

`insufficient_credits` Top up, or raise the key's limit. A very large `max_tokens` can trigger it. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 403 Forbidden Error

`forbidden` The model is outside the key's group or IP allowlist, or free credit cannot call this model. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 404 Not Found Error

`not_found` Unknown model: list the enabled ones with `GET /v1/models`. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 429 Too Many Requests Error

`rate_limit_exceeded` Wait `Retry-After` or `retry_after_seconds`, then retry with backoff. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 500 Internal Server Error

`internal_error`, `temporary_error` Retry once or twice with backoff. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

### 503 Service Unavailable Error

`model_unavailable`, `upstream_timeout`, `temporary_error` Retry with backoff, or use another model. Authentication, routing, rate-limit and unknown-model failures are answered before the model is called, in the BeatAPI envelope: `error.code`, `error.message`, `retryable`, `request_id`. Every other failure keeps the OpenAI SDK shape `{"error": {"message", "type", "code"}}`: the code is in `error.code` and the request id ends `message`. See [Errors](/errors#text-endpoints).

- `map from string to any`

## Types

### V1ResponsesPostRequestBodyContentApplicationJsonSchemaInput

The prompt: a string, or an array of input items for text and image input. Image input is supported by all GPT models on this page.

### V1ResponsesPostRequestBodyContentApplicationJsonSchemaReasoning

Reasoning settings. `reasoning.effort` chooses how much the model reasons before answering. `gpt-6.1-sol`: `low`, `medium`, `high`, `xhigh` and `max`. `none` and `minimal` are not supported. `gpt-5.6-sol`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `gpt-5.6-terra`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `gpt-5.6-luna`: `none`, `low`, `medium`, `high`, `xhigh` and `max`. `none`, `low`, `medium`, `high`, `xhigh`, `max`

- `effort` (enum, optional)
  - Allowed values: `none`, `low`, `medium`, `high`, `xhigh`, `max`

### V1ResponsesPostRequestBodyContentApplicationJsonSchemaToolsItems

### V1ResponsesPostRequestBodyContentApplicationJsonSchemaText

Output format settings, for example `text.format` for structured outputs.

### V1ResponsesPostResponsesContentApplicationJsonSchemaOutputItems

### V1ResponsesPostResponsesContentApplicationJsonSchemaUsage

Token counts. Calls are metered from actual token usage.

## Examples

**Request**

```json
{
  "model": "gpt-6.1-sol",
  "input": "Design a resilient webhook retry strategy for a payments API.",
  "reasoning": {
    "effort": "medium"
  }
}
```

**Response**

```json
{
  "id": "resp_example",
  "model": "gpt-6.1-sol",
  "status": "completed",
  "output": [
    {
      "content": [
        {
          "text": "Retry with exponential backoff and jitter, and make every handler idempotent.",
          "type": "output_text"
        }
      ],
      "role": "assistant",
      "type": "message"
    }
  ],
  "usage": {
    "input_tokens": 19,
    "output_tokens": 16,
    "total_tokens": 35
  },
  "object": "response"
}
```

**SDK Code**

```python Quick start
import requests

url = "https://direct.beatapi.io/v1/responses"

payload = {
    "model": "gpt-6.1-sol",
    "input": "Design a resilient webhook retry strategy for a payments API.",
    "reasoning": { "effort": "medium" }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript Quick start
const url = 'https://direct.beatapi.io/v1/responses';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"model":"gpt-6.1-sol","input":"Design a resilient webhook retry strategy for a payments API.","reasoning":{"effort":"medium"}}'
};

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

```go Quick start
package main

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

func main() {

	url := "https://direct.beatapi.io/v1/responses"

	payload := strings.NewReader("{\n  \"model\": \"gpt-6.1-sol\",\n  \"input\": \"Design a resilient webhook retry strategy for a payments API.\",\n  \"reasoning\": {\n    \"effort\": \"medium\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	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 Quick start
require 'uri'
require 'net/http'

url = URI("https://direct.beatapi.io/v1/responses")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"model\": \"gpt-6.1-sol\",\n  \"input\": \"Design a resilient webhook retry strategy for a payments API.\",\n  \"reasoning\": {\n    \"effort\": \"medium\"\n  }\n}"

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

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

HttpResponse<String> response = Unirest.post("https://direct.beatapi.io/v1/responses")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"model\": \"gpt-6.1-sol\",\n  \"input\": \"Design a resilient webhook retry strategy for a payments API.\",\n  \"reasoning\": {\n    \"effort\": \"medium\"\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://direct.beatapi.io/v1/responses', [
  'body' => '{
  "model": "gpt-6.1-sol",
  "input": "Design a resilient webhook retry strategy for a payments API.",
  "reasoning": {
    "effort": "medium"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp Quick start
using RestSharp;

var client = new RestClient("https://direct.beatapi.io/v1/responses");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"model\": \"gpt-6.1-sol\",\n  \"input\": \"Design a resilient webhook retry strategy for a payments API.\",\n  \"reasoning\": {\n    \"effort\": \"medium\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Quick start
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "model": "gpt-6.1-sol",
  "input": "Design a resilient webhook retry strategy for a payments API.",
  "reasoning": ["effort": "medium"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://direct.beatapi.io/v1/responses")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```