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-proj-abc123def456ghi789jkl012mno345pqr678" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"A sunset over mountains", "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 sunset over mountains",
    "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 sunset over mountains",
    "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 { config } from 'dotenv';

config();

const url = 'https://api.openai.com/v1/images/generations';
const headers = {
  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`,
  'Content-Type': 'application/json'
};
const body = JSON.stringify({
  prompt: 'A sunset over mountains',
  n: 1,
  size: '1024x1024'
});

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

Node.js · axios

import axios from 'axios';
import { config } from 'dotenv';

config();

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 sunset over mountains',
  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 sunset over mountains",
		N:      1,
		Size:   "1024x1024",
	}
	jsonBody, err := json.Marshal(body)
	if err != nil {
		log.Fatal(err)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
	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 sunset over mountains',
    '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);
$result = file_get_contents($url, false, $context);

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

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

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' }

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

request = Net::HTTP::Post.new(url.path, {
  'Authorization' => "Bearer #{api_key}",
  'Content-Type' => 'application/json'
})

request.body = {
  prompt: 'A sunset over mountains',
  n: 1,
  size: '1024x1024'
}.to_json

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 sunset over mountains",
    "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 std::env;
use reqwest::blocking::Client;
use serde_json::json;

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 sunset over mountains",
            "n": 1,
            "size": "1024x1024"
        }))
        .send()?;

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

    let body = response.json::<serde_json::Value>()?;
    println!("{}", body);
    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;
        }

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

        var requestBody = new
        {
            prompt = "A sunset over mountains",
            n = 1,
            size = "1024x1024"
        };

        var response = await client.PostAsJsonAsync(url, requestBody);
        if (!response.IsSuccessStatusCode)
        {
            Console.WriteLine($"Request failed with status: {response.StatusCode}");
            return;
        }

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

Translation notes

  • All implementations use environment variables for secrets (OPENAI_API_KEY)
  • Python examples use requests/httpx, Node.js examples use fetch/axios
  • Go uses net/http with JSON struct for request body
  • PHP uses stream_context_create for simplicity
  • Ruby uses Net::HTTP with JSON serialization
  • Swift uses URLSession with async task
  • Rust uses reqwest blocking client for simplicity
  • C# uses HttpClient with System.Text.Json

Common pitfalls when porting

  • Forgetting to set OPENAI_API_KEY environment variable
  • Not handling HTTP errors properly (status code checks)
  • JSON serialization/deserialization mismatches
  • Missing Content-Type header in some languages
  • SSL/TLS verification issues in Go/Rust if not using default client
  • Async/await confusion in Swift/Rust/Node.js

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 secrets instead of hardcoding?

Environment variables prevent secrets from being committed to version control and allow for different configurations across environments.

How do I handle pagination or large responses?

Use streaming or chunked responses where supported by the library (e.g., httpx in Python, HttpClient in C#).

What if the API requires a different authentication method?

Replace the Authorization header with the appropriate method (e.g., Basic Auth, API key in query params, etc.).