curl -X POST https://aireiter.com/api/v1/responses \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "input": "Write a one-sentence bedtime story about a unicorn.",
    "stream": true
  }'

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://aireiter.com/api/v1"
)

response = client.responses.create(
    model="claude-sonnet-4-5-20250929",
    input="Write a one-sentence bedtime story about a unicorn."
)

print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://aireiter.com/api/v1",
});

const response = await client.responses.create({
  model: "claude-sonnet-4-5-20250929",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "net/http"
)

func main() {
  payload := map[string]interface{}{
    "model":  "claude-sonnet-4-5-20250929",
    "input":  "Write a one-sentence bedtime story about a unicorn.",
    "stream": false,
  }
  body, _ := json.Marshal(payload)

  req, _ := http.NewRequest("POST", "https://aireiter.com/api/v1/responses", bytes.NewBuffer(body))
  req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
  req.Header.Set("Content-Type", "application/json")

  resp, _ := http.DefaultClient.Do(req)
  defer resp.Body.Close()

  var result map[string]interface{}
  json.NewDecoder(resp.Body).Decode(&result)
  fmt.Println(result)
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.*;
import java.util.Map;

public class ResponsesExample {
  public static void main(String[] args) throws Exception {
    var payload = Map.of(
      "model", "claude-sonnet-4-5-20250929",
      "input", "Write a one-sentence bedtime story about a unicorn.",
      "stream", false
    );
    var body = new ObjectMapper().writeValueAsString(payload);
    var request = HttpRequest.newBuilder()
      .uri(URI.create("https://aireiter.com/api/v1/responses"))
      .header("Authorization", "Bearer YOUR_API_KEY")
      .header("Content-Type", "application/json")
      .POST(HttpRequest.BodyPublishers.ofString(body))
      .build();
    var response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
    System.out.println(response.body());
  }
}

<?php
$client = new GuzzleHttp\Client();
$response = $client->post('https://aireiter.com/api/v1/responses', [
  'headers' => [
    'Authorization' => 'Bearer YOUR_API_KEY',
    'Content-Type'  => 'application/json',
  ],
  'json' => [
    'model'  => 'claude-sonnet-4-5-20250929',
    'input'  => 'Write a one-sentence bedtime story about a unicorn.',
    'stream' => false,
  ],
]);
echo $response->getBody();

require 'net/http'
require 'json'

uri = URI('https://aireiter.com/api/v1/responses')
req = Net::HTTP::Post.new(uri, {
  'Authorization' => 'Bearer YOUR_API_KEY',
  'Content-Type'  => 'application/json'
})
req.body = {
  model:  'claude-sonnet-4-5-20250929',
  input:  'Write a one-sentence bedtime story about a unicorn.',
  stream: false
}.to_json

res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

import Foundation

let payload: [String: Any] = [
  "model":  "claude-sonnet-4-5-20250929",
  "input":  "Write a one-sentence bedtime story about a unicorn.",
  "stream": false
]

var request = URLRequest(url: URL(string: "https://aireiter.com/api/v1/responses")!)
request.httpMethod = "POST"
request.setValue("Bearer YOUR_API_KEY", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try! JSONSerialization.data(withJSONObject: payload)

URLSession.shared.dataTask(with: request) { data, _, _ in
  if let data = data { print(String(data: data, encoding: .utf8)!) }
}.resume()

using System.Net.Http;
using System.Net.Http.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

var response = await client.PostAsJsonAsync("https://aireiter.com/api/v1/responses", new {
  model  = "claude-sonnet-4-5-20250929",
  input  = "Write a one-sentence bedtime story about a unicorn.",
  stream = false
});
Console.WriteLine(await response.Content.ReadAsStringAsync());

#include <stdio.h>
#include <curl/curl.h>

int main() {
  CURL *curl = curl_easy_init();
  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "Authorization: Bearer YOUR_API_KEY");
  headers = curl_slist_append(headers, "Content-Type: application/json");

  const char *data = "{\"model\":\"claude-sonnet-4-5-20250929\","
                     "\"input\":\"Write a one-sentence bedtime story about a unicorn.\","
                     "\"stream\":false}";

  curl_easy_setopt(curl, CURLOPT_URL, "https://aireiter.com/api/v1/responses");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
  curl_easy_perform(curl);
  curl_easy_cleanup(curl);
  return 0;
}

import 'dart:convert';
import 'package:http/http.dart' as http;

void main() async {
  final response = await http.post(
    Uri.parse('https://aireiter.com/api/v1/responses'),
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type':  'application/json',
    },
    body: jsonEncode({
      'model':  'claude-sonnet-4-5-20250929',
      'input':  'Write a one-sentence bedtime story about a unicorn.',
      'stream': false,
    }),
  );
  print(response.body);
}

library(httr)
library(jsonlite)

response <- POST(
  "https://aireiter.com/api/v1/responses",
  add_headers(
    Authorization = "Bearer YOUR_API_KEY",
    `Content-Type` = "application/json"
  ),
  body = toJSON(list(
    model  = "claude-sonnet-4-5-20250929",
    input  = "Write a one-sentence bedtime story about a unicorn.",
    stream = FALSE
  ), auto_unbox = TRUE)
)
content(response, "text")

{
  "id": "resp_AbCdEfGhIjKlMnOpQrSt0123",
  "object": "response",
  "created_at": 1742000000.123,
  "status": "completed",
  "model": "claude-sonnet-4-5-20250929",
  "task_id": "task_xyz123",
  "output": [
    {
      "id": "msg_AbCdEfGhIjKl0123",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "The little unicorn tiptoed through the moonlit meadow, leaving a trail of shimmering stardust as she galloped home to her cozy cloud.",
          "annotations": []
        }
      ]
    }
  ],
  "output_text": "The little unicorn tiptoed through the moonlit meadow, leaving a trail of shimmering stardust as she galloped home to her cozy cloud.",
  "usage": {
    "input_tokens": 20,
    "output_tokens": 35,
    "total_tokens": 55,
    "output_tokens_details": {
      "reasoning_tokens": 0
    }
  }
}

{
  "id": "resp_AbCdEfGhIjKlMnOpQrSt0456",
  "object": "response",
  "created_at": 1742000100.456,
  "status": "completed",
  "model": "claude-sonnet-4-5-20250929",
  "task_id": "task_abc456",
  "output": [
    {
      "id": "fc_AbCdEfGhIjKl0456",
      "type": "function_call",
      "call_id": "call_AbCdEfGh",
      "name": "get_weather",
      "arguments": "{\"location\":\"San Francisco\",\"unit\":\"celsius\"}"
    }
  ],
  "output_text": "",
  "usage": {
    "input_tokens": 80,
    "output_tokens": 25,
    "total_tokens": 105,
    "output_tokens_details": {
      "reasoning_tokens": 0
    }
  }
}

{
  "id": "resp_AbCdEfGhIjKlMnOpQrSt0789",
  "object": "response",
  "created_at": 1742000200.789,
  "status": "incomplete",
  "model": "claude-sonnet-4-5-20250929",
  "task_id": "task_def789",
  "output": [
    {
      "id": "msg_AbCdEfGhIjKl0789",
      "type": "message",
      "role": "assistant",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "text": "Here is a very long story that was cut off due to max_output_tokens...",
          "annotations": []
        }
      ]
    }
  ],
  "output_text": "Here is a very long story that was cut off due to max_output_tokens...",
  "incomplete_details": {
    "reason": "max_output_tokens"
  },
  "usage": {
    "input_tokens": 15,
    "output_tokens": 256,
    "total_tokens": 271,
    "output_tokens_details": {
      "reasoning_tokens": 0
    }
  }
}

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "model is required"
  }
}

{
  "type": "error",
  "error": {
    "type": "authentication_error",
    "message": "Invalid API key"
  }
}

{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "Insufficient credits"
  }
}

{
  "type": "error",
  "error": {
    "type": "not_found_error",
    "message": "Model 'unknown-model' not found"
  }
}

{
  "type": "error",
  "error": {
    "type": "api_error",
    "message": "All providers failed"
  }
}