Qaynaq LABS · TOOLS

CURL → CODE · POST · BEARER

cURL → 10 languages

POST api.openai.com · body: json · secrets replaced with env vars.

Source cURL
curl -X POST https://api.openai.com/v1/images/generations \
  -H "Authorization: Bearer sk-1234567890" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"A futuristic cityscape","n":1,"size":"1024x1024"}'

Python · requests

import os
import requests

url = "https://api.openai.com/v1/images/generations"
headers = {
    "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "prompt": "A futuristic cityscape",
    "n": 1,
    "size": "1024x1024"
}

response = requests.post(url, headers=headers, json=data)
response.raise_for_status()
print(response.json())

Python · httpx

import os
import httpx

url = "https://api.openai.com/v1/images/generations"
headers = {
    "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "prompt": "A futuristic cityscape",
    "n": 1,
    "size": "1024x1024"
}

with httpx.Client() as client:
    response = client.post(url, headers=headers, json=data)
    response.raise_for_status()
    print(response.json())

Node.js · fetch

import fetch from 'node-fetch';
import process from 'process';

const url = 'https://api.openai.com/v1/images/generations';
const headers = {
  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
  'Content-Type': 'application/json'
};
const data = {
  prompt: 'A futuristic cityscape',
  n: 1,
  size: '1024x1024'
};

fetch(url, {
  method: 'POST',
  headers,
  body: JSON.stringify(data)
})
  .then(res => {
    if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
    return res.json();
  })
  .then(console.log)
  .catch(console.error);

Node.js · axios

import axios from 'axios';
import process from 'process';

const url = 'https://api.openai.com/v1/images/generations';
const headers = {
  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
  'Content-Type': 'application/json'
};
const data = {
  prompt: 'A futuristic cityscape',
  n: 1,
  size: '1024x1024'
};

axios.post(url, data, { headers })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error('Error:', error.message);
  });

Go · net/http

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

type RequestBody struct {
	Prompt string `json:"prompt"`
	N      int    `json:"n"`
	Size   string `json:"size"`
}

func main() {
	url := "https://api.openai.com/v1/images/generations"
	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		log.Fatal("OPENAI_API_KEY environment variable not set")
	}

	body := RequestBody{
		Prompt: "A futuristic cityscape",
		N:      1,
		Size:   "1024x1024",
	}
	jsonData, err := json.Marshal(body)
	if err != nil {
		log.Fatal(err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		log.Fatal(err)
	}

	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		log.Fatalf("Request failed with status %d: %s", resp.StatusCode, string(body))
	}

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		log.Fatal(err)
	}
	fmt.Println(result)
}

PHP · cURL

<?php

$url = 'https://api.openai.com/v1/images/generations';
$apiKey = getenv('OPENAI_API_KEY');
if (empty($apiKey)) {
    die('OPENAI_API_KEY environment variable not set');
}

$data = [
    'prompt' => 'A futuristic cityscape',
    'n' => 1,
    'size' => '1024x1024'
];

$options = [
    'http' => [
        'header' => [
            "Authorization: Bearer $apiKey",
            "Content-Type: application/json"
        ],
        'method' => 'POST',
        'content' => json_encode($data)
    ]
];

$context = stream_context_create($options);
$response = file_get_contents($url, false, $context);

if ($response === false) {
    die('Request failed');
}

$json = json_decode($response, true);
print_r($json);

Ruby · net/http

require 'net/http'
require 'json'
require 'uri'

url = URI.parse('https://api.openai.com/v1/images/generations')
api_key = ENV.fetch('OPENAI_API_KEY') { raise 'OPENAI_API_KEY environment variable not set' }

request = Net::HTTP::Post.new(url)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'
request.body = {
  prompt: 'A futuristic cityscape',
  n: 1,
  size: '1024x1024'
}.to_json

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

response = http.request(request)

unless response.is_a?(Net::HTTPSuccess)
  raise "Request failed with status #{response.code}: #{response.body}"
end

puts JSON.parse(response.body)

Swift · URLSession

import Foundation

let url = URL(string: "https://api.openai.com/v1/images/generations")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("Bearer \(ProcessInfo.processInfo.environment["OPENAI_API_KEY"] ?? "")", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let body: [String: Any] = [
    "prompt": "A futuristic cityscape",
    "n": 1,
    "size": "1024x1024"
]

request.httpBody = try? JSONSerialization.data(withJSONObject: body)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        print("Request failed with status \((response as? HTTPURLResponse)?.statusCode ?? 0)")
        return
    }
    if let data = data, let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        print(json)
    }
}

task.resume()
RunLoop.main.run()

Rust · reqwest

use reqwest::blocking::Client;
use serde_json::json;
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://api.openai.com/v1/images/generations";
    let api_key = env::var("OPENAI_API_KEY")?;

    let client = Client::new();
    let response = client
        .post(url)
        .header("Authorization", format!("Bearer {}", api_key))
        .header("Content-Type", "application/json")
        .json(&json!({
            "prompt": "A futuristic cityscape",
            "n": 1,
            "size": "1024x1024"
        }))
        .send()?;

    if !response.status().is_success() {
        return Err(format!("Request failed with status: {}", response.status()).into());
    }

    let json: serde_json::Value = response.json()?;
    println!("{}", json);

    Ok(())
}

C# · HttpClient

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var url = "https://api.openai.com/v1/images/generations";
        var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
        if (string.IsNullOrEmpty(apiKey))
        {
            Console.WriteLine("OPENAI_API_KEY environment variable not set");
            return;
        }

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        var requestBody = new
        {
            prompt = "A futuristic cityscape",
            n = 1,
            size = "1024x1024"
        };

        var response = await client.PostAsJsonAsync(url, requestBody);
        response.EnsureSuccessStatusCode();

        var json = await response.Content.ReadAsStringAsync();
        Console.WriteLine(json);
    }
}

Translation notes

  • All implementations use the idiomatic HTTP client for each language.
  • Bearer token is read from environment variable OPENAI_API_KEY to avoid hardcoding.
  • Error handling includes status code checks and basic error reporting.
  • JSON bodies are constructed as objects/dictionaries, not raw strings.
  • Go and Rust examples use blocking clients for simplicity; async variants are available but omitted for brevity.
  • PHP example uses stream context for simplicity; Guzzle could also be used.
  • Swift example uses URLSession and runs the task synchronously for simplicity in a console context.

Common pitfalls when porting

  • Forgetting to set the Content-Type header to application/json can lead to 415 errors.
  • Not checking the HTTP status code before parsing the response body can cause crashes on errors.
  • Hardcoding API keys in code instead of using environment variables is a security risk.
  • In Go, forgetting to close the response body can lead to resource leaks.
  • In Rust, using reqwest's async client requires a runtime like tokio; blocking client is used here for simplicity.
  • In Swift, URLSession tasks are asynchronous by default; the example uses RunLoop for synchronous execution in a console app.

About cURL → code translation

cURL is the lingua franca of API documentation: every vendor docs page ships a cURL snippet you can paste into a terminal and immediately see the API working. Translating that into your actual application code shouldn't be a 20-minute Stack-Overflow safari, but without a good translator it usually is.

Qaynaq Labs' cURL → code tool reads the full command — method, URL, headers, query params, body type, and auth — and emits idiomatic client code in 10 languages. Authentication goes through environment variables by default, request bodies become language-native data structures (not raw JSON strings), and minimal error handling is included.

Frequently asked

Why use environment variables for the API key instead of hardcoding?

Environment variables separate secrets from code, reducing the risk of accidental exposure (e.g., in version control). They also allow different configurations across environments (dev, staging, prod).

Can I use async/await in Go or Rust for better performance?

Yes. In Go, use the net/http package with goroutines or the standard library's http client with context. In Rust, use reqwest's async client with tokio runtime. The examples use blocking clients for simplicity.

How do I handle rate limits or retries in these clients?

Most libraries support middleware or interceptors for retries (e.g., Python's requests with urllib3, Go's net/http with custom RoundTripper). For rate limits, check the response headers (e.g., Retry-After) and implement exponential backoff.