Qaynaq LABS · TOOLS

CURL → CODE · POST · BEARER

cURL → 10 languages

POST api.sendgrid.com · body: json · secrets replaced with env vars.

Source cURL
curl -X POST https://api.sendgrid.com/v3/mail/send \
  -H "Authorization: Bearer SG.12345678-1234-1234-1234-123456789012.abcdefghijklmnopqrstuvwx" \
  -H "Content-Type: application/json" \
  -d '{"personalizations":[{"to":[{"email":"user@example.com"}]}],"from":{"email":"noreply@example.com"},"subject":"Test email","content":[{"type":"text/plain","value":"Hello from SendGrid!"}]}'

Python · requests

import os
import requests

url = "https://api.sendgrid.com/v3/mail/send"
headers = {
    "Authorization": f"Bearer {os.environ['SENDGRID_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "personalizations": [{"to": [{"email": "user@example.com"}]}],
    "from": {"email": "noreply@example.com"},
    "subject": "Test email",
    "content": [{"type": "text/plain", "value": "Hello from SendGrid!"}]
}

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

Python · httpx

import os
import httpx

url = "https://api.sendgrid.com/v3/mail/send"
headers = {
    "Authorization": f"Bearer {os.environ['SENDGRID_API_KEY']}",
    "Content-Type": "application/json"
}
data = {
    "personalizations": [{"to": [{"email": "user@example.com"}]}],
    "from": {"email": "noreply@example.com"},
    "subject": "Test email",
    "content": [{"type": "text/plain", "value": "Hello from SendGrid!"}]
}

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

Node.js · fetch

import fetch from 'node-fetch';
import { config } from 'dotenv';

config();

const url = 'https://api.sendgrid.com/v3/mail/send';
const headers = {
  'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
  'Content-Type': 'application/json'
};
const data = {
  personalizations: [{ to: [{ email: 'user@example.com' }] }],
  from: { email: 'noreply@example.com' },
  subject: 'Test email',
  content: [{ type: 'text/plain', value: 'Hello from SendGrid!' }]
};

try {
  const response = await fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(data)
  });
  if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
} catch (error) {
  console.error('Request failed:', error);
}

Node.js · axios

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

config();

const url = 'https://api.sendgrid.com/v3/mail/send';
const headers = {
  'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
  'Content-Type': 'application/json'
};
const data = {
  personalizations: [{ to: [{ email: 'user@example.com' }] }],
  from: { email: 'noreply@example.com' },
  subject: 'Test email',
  content: [{ type: 'text/plain', value: 'Hello from SendGrid!' }]
};

try {
  const response = await axios.post(url, data, { headers });
  if (response.status >= 400) throw new Error(`HTTP error! status: ${response.status}`);
} catch (error) {
  console.error('Request failed:', error);
}

Go · net/http

package main

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

type Personalization struct {
	To []struct {
		Email string `json:"email"`
	} `json:"to"`
}

type Email struct {
	Email string `json:"email"`
}

type Content struct {
	Type  string `json:"type"`
	Value string `json:"value"`
}

type RequestBody struct {
	Personalizations []Personalization `json:"personalizations"`
	From             Email           `json:"from"`
	Subject          string          `json:"subject"`
	Content          []Content       `json:"content"`
}

func main() {
	url := "https://api.sendgrid.com/v3/mail/send"
	apiKey := os.Getenv("SENDGRID_API_KEY")
	if apiKey == "" {
		fmt.Println("SENDGRID_API_KEY environment variable not set")
		os.Exit(1)
	}

	body := RequestBody{
		Personalizations: []Personalization{
			{To: []struct{ Email string `json:"email"` }{
				{Email: "user@example.com"},
			}},
		},
		From:    Email{Email: "noreply@example.com"},
		Subject: "Test email",
		Content: []Content{
			{Type: "text/plain", Value: "Hello from SendGrid!"},
		},
	}

	jsonData, err := json.Marshal(body)
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		os.Exit(1)
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Error creating request:", err)
		os.Exit(1)
	}

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

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error making request:", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		body, _ := io.ReadAll(resp.Body)
		fmt.Printf("HTTP error! status: %d, body: %s\n", resp.StatusCode, body)
		os.Exit(1)
	}
}

PHP · cURL

<?php

$url = 'https://api.sendgrid.com/v3/mail/send';
$apiKey = getenv('SENDGRID_API_KEY');
if (empty($apiKey)) {
    die('SENDGRID_API_KEY environment variable not set');
}

$data = [
    'personalizations' => [
        ['to' => [['email' => 'user@example.com']]]
    ],
    'from' => ['email' => 'noreply@example.com'],
    'subject' => 'Test email',
    'content' => [
        ['type' => 'text/plain', 'value' => 'Hello from SendGrid!']
    ]
];

$options = [
    'http' => [
        'header' => [
            "Authorization: Bearer $apiKey",
            "Content-Type: application/json"
        ],
        'method' => 'POST',
        'content' => json_encode($data),
        'ignore_errors' => true
    ]
];

$context = stream_context_create($options);
$result = file_get_contents($url, false, $context);

if ($http_response_header[0] !== 'HTTP/1.1 202 Accepted') {
    die('Request failed: ' . $result);
}

Ruby · net/http

require 'net/http'
require 'json'
require 'uri'

url = URI.parse('https://api.sendgrid.com/v3/mail/send')
api_key = ENV.fetch('SENDGRID_API_KEY') { raise 'SENDGRID_API_KEY environment variable not set' }

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

request.body = {
  personalizations: [{ to: [{ email: 'user@example.com' }] }],
  from: { email: 'noreply@example.com' },
  subject: 'Test email',
  content: [{ type: 'text/plain', value: 'Hello from SendGrid!' }]
}.to_json

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

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

Swift · URLSession

import Foundation

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

let body: [String: Any] = [
    "personalizations": [["to": ["email": "user@example.com"]]],
    "from": ["email": "noreply@example.com"],
    "subject": "Test email",
    "content": [["type": "text/plain", "value": "Hello from SendGrid!"]]
]

request.httpBody = try JSONSerialization.data(withJSONObject: body)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Request failed: \(error)")
        return
    }
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode < 400 else {
        print("HTTP error! status: \((response as? HTTPURLResponse)?.statusCode ?? 0)")
        return
    }
}
task.resume()
RunLoop.main.run()

Rust · reqwest

use reqwest::blocking::Client;
use serde_json::json;
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://api.sendgrid.com/v3/mail/send";
    let api_key = env::var("SENDGRID_API_KEY")?;

    let client = Client::new();
    let body = json!({
        "personalizations": [{"to": [{"email": "user@example.com"}]}],
        "from": {"email": "noreply@example.com"},
        "subject": "Test email",
        "content": [{"type": "text/plain", "value": "Hello from SendGrid!"}]
    });

    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!("HTTP error! status: {}", response.status()).into());
    }

    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.sendgrid.com/v3/mail/send";
        var apiKey = Environment.GetEnvironmentVariable("SENDGRID_API_KEY");
        if (string.IsNullOrEmpty(apiKey))
        {
            Console.WriteLine("SENDGRID_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 body = new
        {
            personalizations = new[] { new { to = new[] { new { email = "user@example.com" } } } },
            from = new { email = "noreply@example.com" },
            subject = "Test email",
            content = new[] { new { type = "text/plain", value = "Hello from SendGrid!" } }
        };

        var response = await client.PostAsJsonAsync(url, body);
        if (!response.IsSuccessStatusCode)
        {
            Console.WriteLine($"HTTP error! status: {response.StatusCode}");
        }
    }
}

Translation notes

  • All implementations use idiomatic HTTP clients for their respective languages.
  • Bearer token is read from environment variable SENDGRID_API_KEY to avoid hardcoding.
  • JSON bodies are constructed as objects/dictionaries, not raw strings.
  • Error handling checks HTTP status codes and raises/throws on failure.
  • Python implementations use both requests and httpx for completeness.

Common pitfalls when porting

  • Forgetting to set the Content-Type header to application/json.
  • Not reading the API key from environment variables, leading to hardcoded secrets.
  • Ignoring SSL/TLS verification in Go or Rust (not shown here but common in low-level clients).
  • Assuming the API key is always present in the environment (always validate).

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 exposure in version control or logs. They also allow different deployments to use different credentials without code changes.

How do I handle rate limits or retries in these clients?

Most HTTP clients support interceptors or middleware for retries. For example, in Python you can use requests-toolbelt or httpx with custom retry logic. In Go, you can implement a retry wrapper around the HTTP client.