Qaynaq LABS · TOOLS

CURL → CODE · PUT · BEARER

cURL → 10 languages

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

Source cURL
curl -X PUT https://api.openai.com/v1/models/text-davinci-002 \
  -H "Authorization: Bearer sk-proj-abc123def456ghi789jkl012mno345pqr678" \
  -d '{"name":"text-davinci-002", "description":"Updated model description"}'

Python · requests

import os
import requests

url = "https://api.openai.com/v1/models/text-davinci-002"
headers = {"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"}
data = {"name": "text-davinci-002", "description": "Updated model description"}

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

Python · httpx

import os
import httpx

url = "https://api.openai.com/v1/models/text-davinci-002"
headers = {"Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}"}
data = {"name": "text-davinci-002", "description": "Updated model description"}

with httpx.Client() as client:
    response = client.put(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/models/text-davinci-002';
const headers = {
  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
};
const body = JSON.stringify({
  name: 'text-davinci-002',
  description: 'Updated model description'
});

fetch(url, {
  method: 'PUT',
  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(err));

Node.js · axios

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

config();

const url = 'https://api.openai.com/v1/models/text-davinci-002';
const headers = {
  'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
};
const data = {
  name: 'text-davinci-002',
  description: 'Updated model description'
};

axios.put(url, data, { headers })
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error);
  });

Go · net/http

package main

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

type Model struct {
	Name        string `json:"name"`
	Description string `json:"description"`
}

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

	model := Model{
		Name:        "text-davinci-002",
		Description: "Updated model description",
	}
	body, err := json.Marshal(model)
	if err != nil {
		log.Fatal(err)
	}

	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(body))
	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/models/text-davinci-002';
$apiKey = getenv('OPENAI_API_KEY');
if (empty($apiKey)) {
    die('OPENAI_API_KEY environment variable not set');
}

$data = [
    'name' => 'text-davinci-002',
    'description' => 'Updated model description'
];

$options = [
    'http' => [
        'method' => 'PUT',
        'header' => "Authorization: Bearer $apiKey\r\nContent-Type: application/json",
        '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/models/text-davinci-002')
api_key = ENV.fetch('OPENAI_API_KEY')

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

request = Net::HTTP::Put.new(url.path)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'
request.body = { name: 'text-davinci-002', description: 'Updated model description' }.to_json

response = http.request(request)

unless response.is_a?(Net::HTTPSuccess)
  raise "HTTP request failed: #{response.code} #{response.message}"
end

puts JSON.parse(response.body)

Swift · URLSession

import Foundation

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

let body: [String: Any] = [
    "name": "text-davinci-002",
    "description": "Updated model description"
]
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;
use std::env;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://api.openai.com/v1/models/text-davinci-002";
    let api_key = env::var("OPENAI_API_KEY")?;

    let client = reqwest::Client::new();
    let response = client
        .put(url)
        .header("Authorization", format!("Bearer {}", api_key))
        .json(&json!({
            "name": "text-davinci-002",
            "description": "Updated model description"
        }))
        .send()
        .await?;

    if !response.status().is_success() {
        let status = response.status();
        let body = response.text().await?;
        return Err(format!("Request failed with status {}: {}", status, body).into());
    }

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

C# · HttpClient

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

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

        var httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", apiKey);

        var model = new
        {
            name = "text-davinci-002",
            description = "Updated model description"
        };

        var response = await httpClient.PutAsJsonAsync(url, model);
        if (!response.IsSuccessStatusCode)
        {
            var errorContent = await response.Content.ReadAsStringAsync();
            Console.WriteLine($"Request failed with status {response.StatusCode}: {errorContent}");
            return;
        }

        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.
  • JSON bodies are constructed as objects/dicts, not raw strings.
  • Error handling checks HTTP status and reads response body on failure.
  • Go implementation uses a struct for the request body for type safety.
  • Swift uses async/await via URLSession.dataTask.
  • Rust uses reqwest with async/await and serde_json for JSON handling.
  • C# uses HttpClient with PutAsJsonAsync for simplicity.

Common pitfalls when porting

  • Forgetting to set the Content-Type header to application/json (Go, Ruby, Swift).
  • Not handling environment variable absence (Go, C#).
  • Assuming synchronous HTTP calls work in Swift (must use async/await).
  • Not checking HTTP status codes before parsing response (all languages).
  • Using raw strings for JSON bodies instead of proper serialization (all languages).

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 are the standard way to handle secrets in applications. They prevent accidental exposure of sensitive data in version control or logs.

How do I handle pagination or large responses in these clients?

Most HTTP clients provide streaming or chunked response handling. For example, in Python you can use `response.iter_content()` or in Go `io.ReadAll(resp.Body)`.

Can I use these clients in a synchronous context in Swift?

No. Swift's URLSession requires async/await or completion handlers. Use `URLSession.shared.dataTask` with a completion handler if you must avoid async/await.