Qaynaq LABS · TOOLS

CURL → CODE · GET · BEARER

cURL → 10 languages

GET api.stripe.com · secrets replaced with env vars.

Source cURL
curl -X GET https://api.stripe.com/v1/charges/ch_1234567890 --header "Authorization: Bearer sk_test_1234567890"

Python · requests

import os
import requests

response = requests.get(
    "https://api.stripe.com/v1/charges/ch_1234567890",
    headers={"Authorization": f"Bearer {os.environ['STRIPE_SECRET_KEY']}"}
)
response.raise_for_status()
print(response.json())

Python · httpx

import os
import httpx

with httpx.Client() as client:
    response = client.get(
        "https://api.stripe.com/v1/charges/ch_1234567890",
        headers={"Authorization": f"Bearer {os.environ['STRIPE_SECRET_KEY']}"}
    )
    response.raise_for_status()
    print(response.json())

Node.js · fetch

import fetch from 'node-fetch';

const response = await fetch('https://api.stripe.com/v1/charges/ch_1234567890', {
  headers: {
    'Authorization': `Bearer ${process.env.STRIPE_SECRET_KEY}`
  }
});
if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
const data = await response.json();
console.log(data);

Node.js · axios

import axios from 'axios';

const response = await axios.get('https://api.stripe.com/v1/charges/ch_1234567890', {
  headers: {
    'Authorization': `Bearer ${process.env.STRIPE_SECRET_KEY}`
  }
});
console.log(response.data);

Go · net/http

package main

import (
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.stripe.com/v1/charges/ch_1234567890", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("STRIPE_SECRET_KEY"))

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

	if resp.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("HTTP error! status: %s", resp.Status))
	}

	// Handle response body as needed
}

PHP · cURL

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.stripe.com/v1/charges/ch_1234567890');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . getenv('STRIPE_SECRET_KEY')
]);

$response = curl_exec($ch);
if (curl_errno($ch)) {
    throw new Exception('Curl error: ' . curl_error($ch));
}
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($httpCode !== 200) {
    throw new Exception("HTTP error! status: $httpCode");
}

$data = json_decode($response, true);
print_r($data);
curl_close($ch);
?>

Ruby · net/http

require 'net/http'
require 'json'

uri = URI('https://api.stripe.com/v1/charges/ch_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{ENV['STRIPE_SECRET_KEY']}"

response = http.request(request)
unless response.is_a?(Net::HTTPSuccess)
  raise "HTTP error! status: #{response.code}"
end

puts JSON.parse(response.body)

Swift · URLSession

import Foundation

let url = URL(string: "https://api.stripe.com/v1/charges/ch_1234567890")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(ProcessInfo.processInfo.environment["STRIPE_SECRET_KEY"] ?? "")", forHTTPHeaderField: "Authorization")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        fatalError("Error: \(error)")
    }
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        fatalError("HTTP error! status: \((response as? HTTPURLResponse)?.statusCode ?? 0)")
    }
    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;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = reqwest::Client::new();
    let response = client
        .get("https://api.stripe.com/v1/charges/ch_1234567890")
        .header("Authorization", format!("Bearer {}", env::var("STRIPE_SECRET_KEY").unwrap()))
        .send()
        .await?;

    if !response.status().is_success() {
        panic!("HTTP error! status: {}", response.status());
    }

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

C# · HttpClient

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

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue(
            "Bearer", Environment.GetEnvironmentVariable("STRIPE_SECRET_KEY")
        );

        var response = await client.GetAsync("https://api.stripe.com/v1/charges/ch_1234567890");
        response.EnsureSuccessStatusCode();
        var content = await response.Content.ReadAsStringAsync();
        Console.WriteLine(content);
    }
}

Translation notes

  • All implementations use the idiomatic HTTP client for each language.
  • Bearer token is read from environment variable STRIPE_SECRET_KEY.
  • Error handling checks HTTP status and raises an exception if not successful.
  • JSON response is parsed into a native data structure where applicable.
  • Go and Rust examples require async/await for simplicity in handling responses.

Common pitfalls when porting

  • Forgetting to set the STRIPE_SECRET_KEY environment variable will cause runtime errors.
  • In Go, not closing the response body can lead to resource leaks.
  • In Swift, the example uses a synchronous approach for simplicity; real apps should handle async properly.
  • In Rust, the reqwest client requires the tokio runtime for async operations.
  • In PHP, curl_setopt must be used carefully to avoid security issues with raw output.

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?

Environment variables are a secure way to handle secrets as they are not hardcoded in the source code, reducing the risk of accidental exposure.

How do I handle pagination in the response?

Check the response for pagination links or metadata (e.g., 'has_more' in Stripe API) and make subsequent requests as needed.

Can I use a different HTTP client library?

Yes, but ensure it supports the same features (e.g., headers, auth, JSON parsing) and follows idiomatic practices for the language.

Why does the Swift example use RunLoop.main.run()?

It keeps the program running to allow the async URLSession task to complete. In a real app, use proper async/await or completion handlers.