Welcome to the future.

exports.handler = async (event) => {
  const { default: axios } = require('axios');

  const headers = {
    'Authorization': 'Bearer YOUR_TOKEN_HERE',
    'Content-Type': 'application/json'
  };

  const serverData = {
    name: 'Lambda Server',
    region: 'eu-west-1',
    unit: 'papermc'
  };

  try {
    const response = await axios.post('http://localhost:3000/api/servers', serverData, { headers });

    return {
      statusCode: 200,
      body: JSON.stringify({ message: "Server created", data: response.data }),
    };
  } catch (error) {
    return {
      statusCode: error.response?.status || 500,
      body: JSON.stringify({ message: "Failed to create server", error: error.message }),
    };
  }
};

require 'httparty'

response = HTTParty.post(
  'http://localhost:3000/api/servers',
  headers: {
    'Authorization' => 'Bearer YOUR_TOKEN_HERE',
    'Content-Type' => 'application/json'
  },
  body: {
    name: 'Ruby Server',
    region: 'ap-southeast-1',
    unit: 't2.small'
  }.to_json
)

puts "Server created: #{response.body}" if response.success?

import requests

headers = {
  "Authorization": "Bearer YOUR_TOKEN_HERE",
  "Content-Type": "application/json"
}

server_data = {
  "name": "Python Server",
  "region": "us-west-2",
  "unit": "papermc"
}

response = requests.post(
  "http://localhost:3000/api/servers",
  json=server_data,
  headers=headers
)

if response.status_code == 200:
  print(f"Server created: {response.json()}")
else:
  print(f"Error: {response.status_code}, {response.text}")

<?php
$client = new GuzzleHttp\Client();

$response = $client->post('http://localhost:3000/api/servers', [
  'headers' => [
    'Authorization' => 'Bearer YOUR_TOKEN_HERE',
    'Content-Type' => 'application/json'
  ],
  'json' => [
    'name' => 'PHP Server',
    'region' => 'eu-central-1',
    'unit' => 't2.medium'
  ]
]);

echo "Status: " . $response->getStatusCode() . "\n";
echo "Response: " . $response->getBody();

package main

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

type Server struct {
	Name         string `json:"name"`
	Region       string `json:"region"`
	unit string `json:"unit"`
}

func main() {
	server := Server{
		Name:         "Go Server",
		Region:       "ap-northeast-1",
		unit: "papermc",
	}
	
	payload, err := json.Marshal(server)
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}
	
	req, err := http.NewRequest("POST", "http://localhost:3000/api/servers", bytes.NewBuffer(payload))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}
	
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer YOUR_TOKEN_HERE")
	
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error making request:", err)
		return
	}
	defer resp.Body.Close()
	
	fmt.Println("Response Status:", resp.Status)
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<>(), Box<dyn std::error::Error>> {
    let client = Client::new();
    
    let response = client.post("http://localhost:3000/api/servers")
        .header("Authorization", "Bearer YOUR_TOKEN_HERE")
        .header("Content-Type", "application/json")
        .json(&json!({
            "name": "Rust Server",
            "region": "us-east-2",
            "unit": "papermc"
        }))
        .send()
        .await?;
    
    if response.status().is_success() {
        println!("Server created successfully");
        let response_text = response.text().await?;
        println!("Response: {}", response_text);
    } else {
        println!("Failed to create server: {}", response.status());
    }
    
    Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ServerApiExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        String jsonRequest = """
            {
                "name": "Java Server",
                "region": "sa-east-1",
                "unit": "papermc"
            }
            """;
        
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("http://localhost:3000/api/servers"))
            .header("Authorization", "Bearer YOUR_TOKEN_HERE")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonRequest))
            .build();
        
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Status code: " + response.statusCode());
        System.out.println("Response: " + response.body());
    }
}

HTTPoison.start()

headers = [
  {"Authorization", "Bearer YOUR_TOKEN_HERE"},
  {"Content-Type", "application/json"}
]

body = Jason.encode!(%{
  name: "Elixir Server",
  region: "eu-west-2",
  unit: "t2.nano"
})

case HTTPoison.post("http://localhost:3000/api/servers", body, headers) do
  {:ok, %{status_code: 200, body: response_body}} ->
    IO.puts "Server created successfully"
    IO.puts "Response: #{response_body}"
  {:ok, %{status_code: status_code}} ->
    IO.puts "Failed with status code: #{status_code}"
  {:error, error} ->
    IO.puts "Error: #{inspect error}"
end

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

class Program
{
    static async Task Main()
    {
        var server = new
        {
            name = ".NET Server",
            region = "ap-south-1",
            unit = "papermc"
        };
        
        using var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_TOKEN_HERE");
        
        string json = JsonSerializer.Serialize(server);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync("http://localhost:3000/api/servers", content);
        
        Console.WriteLine($"Status: {response.StatusCode}");
        if (response.IsSuccessStatusCode)
        {
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine($"Response: {responseBody}");
        }
    }
}

curl -X POST http://localhost:3000/api/servers \
  -H "Authorization: Bearer YOUR_TOKEN_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "REST Server",
    "region": "af-south-1",
    "unit": "t4g.micro"
  }'

EHLO smtp.myapp.com
MAIL FROM:<noreply@myapp.com>
RCPT TO:<user@example.com>
DATA
Subject: SMTP Welcome

Welcome to MyApp via SMTP!
.
QUIT