Qaynaq LABS · TOOLS

CURL → CODE · POST · BEARER

cURL → 10 languages

POST generativelanguage.googleapis.com · body: json · secrets replaced with env vars.

Source cURL
curl -X POST https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent \
  -H "Authorization: Bearer AIzaSyABCdefGHIJKLMNopQRSTUVWXYZ1234567890" \
  -H "Content-Type: application/json" \
  -d '{"contents": [{"parts": [{"text": "Write a poem about the ocean."}]}]}'

Python · requests

import os
import requests

url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
headers = {
    "Authorization": f"Bearer {os.environ['GOOGLE_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "contents": [{"parts": [{"text": "Write a poem about the ocean."}]}]
}

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

Python · httpx

import os
import httpx

url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
headers = {
    "Authorization": f"Bearer {os.environ['GOOGLE_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "contents": [{"parts": [{"text": "Write a poem about the ocean."}]}]
}

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

Node.js · fetch

const fetch = require('node-fetch');

const url = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
const headers = {
  'Authorization': `Bearer ${process.env.GOOGLE_API_KEY}`,
  'Content-Type': 'application/json'
};
const body = {
  contents: [{ parts: [{ text: 'Write a poem about the ocean.' }] }]
};

fetch(url, {
  method: 'POST',
  headers,
  body: JSON.stringify(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

const axios = require('axios');

const url = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
const headers = {
  'Authorization': `Bearer ${process.env.GOOGLE_API_KEY}`,
  'Content-Type': 'application/json'
};
const data = {
  contents: [{ parts: [{ text: 'Write a poem about the ocean.' }] }]
};

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 {
	Contents []struct {
		Parts []struct {
			Text string `json:"text"`
		} `json:"parts"`
	} `json:"contents"`
}

func main() {
	url := "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
	apiKey := os.Getenv("GOOGLE_API_KEY")
	if apiKey == "" {
		log.Fatal("GOOGLE_API_KEY environment variable not set")
	}

	body := RequestBody{
		Contents: []struct {
			Parts []struct {
				Text string `json:"text"`
			} `json:"parts"`
		}{
			{
				Parts: []struct {
					Text string `json:"text"`
				}{
					{Text: "Write a poem about the ocean."},
				},
			},
		},
	}

	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 %s: %s", resp.Status, 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://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent';
$apiKey = getenv('GOOGLE_API_KEY');
if (empty($apiKey)) {
    die('GOOGLE_API_KEY environment variable not set');
}

$headers = [
    'Authorization: Bearer ' . $apiKey,
    'Content-Type: application/json'
];

$data = [
    'contents' => [
        [
            'parts' => [
                ['text' => 'Write a poem about the ocean.']
            ]
        ]
    ]
];

$options = [
    'http' => [
        'header' => $headers,
        'method' => 'POST',
        'content' => json_encode($data),
        'ignore_errors' => true
    ]
];

$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://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent')
api_key = ENV.fetch('GOOGLE_API_KEY') { raise 'GOOGLE_API_KEY environment variable not set' }

headers = {
  'Authorization' => "Bearer #{api_key}",
  'Content-Type' => 'application/json'
}

body = {
  contents: [{
    parts: [{
      text: 'Write a poem about the ocean.'
    }]
  }]
}

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

request = Net::HTTP::Post.new(url.request_uri, headers)
request.body = body.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://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent")!
var request = URLRequest(url: url)
request.httpMethod = "POST"

let apiKey = ProcessInfo.processInfo.environment["GOOGLE_API_KEY"] ?? { fatalError("GOOGLE_API_KEY environment variable not set") }()
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let body: [String: Any] = [
    "contents": [
        [
            "parts": [
                ["text": "Write a poem about the ocean."]
            ]
        ]
    ]
]

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://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent";
    let api_key = env::var("GOOGLE_API_KEY")?;

    let client = Client::new();
    let body = json!({
        "contents": [{
            "parts": [{
                "text": "Write a poem about the ocean."
            }]
        }]
    });

    let response = client
        .post(url)
        .header("Authorization", format!("Bearer {}", api_key))
        .header("Content-Type", "application/json")
        .json(&body)
        .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.Threading.Tasks;
using System.Text.Json;

class Program
{
    static async Task Main()
    {
        var url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent";
        var apiKey = Environment.GetEnvironmentVariable("GOOGLE_API_KEY");
        if (string.IsNullOrEmpty(apiKey))
        {
            throw new Exception("GOOGLE_API_KEY environment variable not set");
        }

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

        var body = new
        {
            contents = new[]
            {
                new
                {
                    parts = new[]
                    {
                        new { text = "Write a poem about the ocean." }
                    }
                }
            }
        };

        var response = await client.PostAsJsonAsync(url, body);
        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 GOOGLE_API_KEY to avoid hardcoding.
  • JSON body is constructed as a native object/struct, not a raw string.
  • Error handling checks HTTP status and raises/throws on failure.
  • Minimal dependencies are used (e.g., requests in Python, axios in Node.js).

Common pitfalls when porting

  • Forgetting to set the Content-Type header to application/json can cause the server to reject the request.
  • Not reading the API key from an environment variable may expose secrets in version control.
  • In Go, forgetting to close the response body can lead to resource leaks.
  • In Swift, the URLSession task must be started with task.resume().
  • In Rust, the reqwest blocking client is used for simplicity; async would require more boilerplate.

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 separate configuration from code, reducing the risk of accidental secret exposure in version control or logs.

Can I use async/await in Rust instead of blocking?

Yes, replace reqwest::blocking with reqwest and use async/await with a runtime like tokio.

How do I handle pagination or streaming responses?

Most libraries provide streaming or pagination helpers; check the library documentation for your specific use case.