Qaynaq LABS · TOOLS

CURL → CODE · GET · BEARER

cURL → 10 languages

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

Source cURL
curl -X GET https://api.sendgrid.com/v3/suppression/bounces \
  --header "Authorization: Bearer SG.1234567890abcdef" \
  --header "Content-Type: application/json"

Python · requests

import os
import requests

response = requests.get(
    "https://api.sendgrid.com/v3/suppression/bounces",
    headers={
        "Authorization": f"Bearer {os.environ['SENDGRID_API_KEY']}",
        "Content-Type": "application/json"
    }
)
response.raise_for_status()
print(response.json())

Python · httpx

import os
import httpx

with httpx.Client() as client:
    response = client.get(
        "https://api.sendgrid.com/v3/suppression/bounces",
        headers={
            "Authorization": f"Bearer {os.environ['SENDGRID_API_KEY']}",
            "Content-Type": "application/json"
        }
    )
    response.raise_for_status()
    print(response.json())

Node.js · fetch

import fetch from 'node-fetch';

const response = await fetch('https://api.sendgrid.com/v3/suppression/bounces', {
  method: 'GET',
  headers: {
    'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
    'Content-Type': 'application/json'
  }
});
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.sendgrid.com/v3/suppression/bounces', {
  headers: {
    'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
    'Content-Type': 'application/json'
  }
});
console.log(response.data);

Go · net/http

package main

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

func main() {
	client := &http.Client{}
	req, err := http.NewRequest("GET", "https://api.sendgrid.com/v3/suppression/bounces", nil)
	if err != nil {
		panic(err)
	}

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

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

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

	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
}

PHP · cURL

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.sendgrid.com/v3/suppression/bounces');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer ' . getenv('SENDGRID_API_KEY'),
    'Content-Type: application/json'
]);

$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, body: $response");
}

$decoded = json_decode($response, true);
print_r($decoded);
curl_close($ch);

Ruby · net/http

require 'net/http'
require 'json'

uri = URI('https://api.sendgrid.com/v3/suppression/bounces')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{ENV['SENDGRID_API_KEY']}"
request['Content-Type'] = 'application/json'

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

puts JSON.parse(response.body)

Swift · URLSession

import Foundation

let url = URL(string: "https://api.sendgrid.com/v3/suppression/bounces")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(ProcessInfo.processInfo.environment["SENDGRID_API_KEY"] ?? "")", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let client = reqwest::Client::new();
    let response = client
        .get("https://api.sendgrid.com/v3/suppression/bounces")
        .header("Authorization", format!("Bearer {}", std::env::var("SENDGRID_API_KEY")?))
        .header("Content-Type", "application/json")
        .send()
        .await?;

    if !response.status().is_success() {
        return Err(format!("HTTP error! status: {}", response.status()).into());
    }

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

C# · HttpClient

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

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.BaseAddress = new Uri("https://api.sendgrid.com");
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
            "Bearer", Environment.GetEnvironmentVariable("SENDGRID_API_KEY")
        );
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        var response = await client.GetAsync("/v3/suppression/bounces");
        if (!response.IsSuccessStatusCode)
        {
            throw new Exception($"HTTP error! status: {response.StatusCode}");
        }

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

Translation notes

  • All implementations use environment variables for the API key (SENDGRID_API_KEY).
  • Error handling is minimal but includes status code checks and body reading where applicable.
  • The Python httpx example uses a context manager for the client.
  • The Go example uses the standard library's http.Client.
  • The Swift example uses URLSession and runs the task in the main run loop.
  • The Rust example uses reqwest with async/await and tokio runtime.
  • The C# example uses HttpClient with async/await.

Common pitfalls when porting

  • Forgetting to set the SENDGRID_API_KEY environment variable before running the code.
  • Not handling HTTP errors properly (e.g., ignoring status codes).
  • In Go, not closing the response body can lead to resource leaks.
  • In Swift, forgetting to call RunLoop.main.run() will prevent the async task from completing.
  • In Rust, not enabling the tokio feature in Cargo.toml will cause compilation errors.
  • In PHP, not checking for curl errors can hide issues.

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 it?

Environment variables are safer for secrets as they are not committed to version control and can be managed separately from the code.

How do I set the SENDGRID_API_KEY environment variable?

For local development, use `export SENDGRID_API_KEY=your_api_key` in Unix-like shells or `set SENDGRID_API_KEY=your_api_key` in Windows CMD. For production, use your deployment platform's secret management system.

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

It ensures the async URLSession task completes before the program exits, as Swift's concurrency model requires explicit event loop management in command-line apps.