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()
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()
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);
}
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);
}
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
$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);
}
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
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()
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(())
}
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}");
}
}
}