One REST call to send, read & manage email.

const API_URL = "https://mail.syncgaze.in/api/v1/webmail";
const TOKEN   = "sg_YOUR_TOKEN";
const headers = { Authorization: `Bearer ${TOKEN}` };

// List folders
const folders = await fetch(`${API_URL}/folders/`, { headers });
console.log(await folders.json());

// List INBOX messages
const msgs = await fetch(
  `${API_URL}/messages/?folder=INBOX&limit=20`, { headers }
);
console.log(await msgs.json());

// Send an email
const res = await fetch(`${API_URL}/send/`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({
    to:      [{ email: "recipient@example.com" }],
    subject: "Hello from JS",
    body:    "<p>Sent via SyncGaze API</p>",
  }),
});
console.log(res.status, await res.json());

# List folders
curl -H "Authorization: Bearer sg_YOUR_TOKEN" \
     https://mail.syncgaze.in/api/v1/webmail/folders/

# List INBOX messages
curl -H "Authorization: Bearer sg_YOUR_TOKEN" \
     "https://mail.syncgaze.in/api/v1/webmail/messages/?folder=INBOX&limit=20"

# Send an email
curl -X POST \
     -H "Authorization: Bearer sg_YOUR_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"to":[{"email":"recipient@example.com"}],"subject":"Hello","body":"<p>Hi!</p>"}' \
     https://mail.syncgaze.in/api/v1/webmail/send/

<?php
// composer require guzzlehttp/guzzle
use GuzzleHttp\Client;

$API = "https://mail.syncgaze.in/api/v1/webmail";
$client = new Client([
    'headers' => ['Authorization' => "Bearer sg_YOUR_TOKEN"],
]);

// List folders
$folders = $client->get("$API/folders/");
var_dump(json_decode($folders->getBody(), true));

// List INBOX messages
$msgs = $client->get("$API/messages/", [
    'query' => ['folder' => 'INBOX', 'limit' => 20],
]);

// Send an email
$res = $client->post("$API/send/", [
    'json' => [
        'to'      => [['email' => 'recipient@example.com']],
        'subject' => 'Hello from PHP',
        'body'    => '<p>Sent via SyncGaze API</p>',
    ],
]);
echo $res->getStatusCode(); // 201

package main

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

const (
    api   = "https://mail.syncgaze.in/api/v1/webmail"
    token = "sg_YOUR_TOKEN"
)

func apiGet(path string) []byte {
    req, _ := http.NewRequest("GET", api+path, nil)
    req.Header.Set("Authorization", "Bearer "+token)
    resp, _ := http.DefaultClient.Do(req)
    body, _ := io.ReadAll(resp.Body)
    return body
}

func main() {
    fmt.Println(string(apiGet("/folders/")))
    fmt.Println(string(apiGet("/messages/?folder=INBOX&limit=20")))

    // Send an email
    payload, _ := json.Marshal(map[string]any{
        "to":      []map[string]string{{"email": "recipient@example.com"}},
        "subject": "Hello from Go",
        "body":    "<p>Sent via SyncGaze API</p>",
    })
    req, _ := http.NewRequest("POST", api+"/send/", bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer "+token)
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    fmt.Println(resp.StatusCode)
}

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

API = "https://mail.syncgaze.in/api/v1/webmail"
TOKEN = "sg_YOUR_TOKEN"

def api_get(path)
  uri = URI("#{API}#{path}")
  req = Net::HTTP::Get.new(uri)
  req['Authorization'] = "Bearer #{TOKEN}"
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  JSON.parse(http.request(req).body)
end

p api_get('/folders/')
p api_get('/messages/?folder=INBOX&limit=20')

# Send an email
uri = URI("#{API}/send/")
req = Net::HTTP::Post.new(uri)
req['Authorization'] = "Bearer #{TOKEN}"
req['Content-Type']  = 'application/json'
req.body = { to: [{ email: 'recipient@example.com' }],
             subject: 'Hello from Ruby',
             body: '<p>Hi!</p>' }.to_json
http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = true
p http.request(req).code

// Java 11+, no external dependencies
import java.net.URI; import java.net.http.*;

var client = HttpClient.newHttpClient();
var api    = "https://mail.syncgaze.in/api/v1/webmail";
var token  = "sg_YOUR_TOKEN";

// List folders
var req = HttpRequest.newBuilder()
    .uri(URI.create(api + "/folders/"))
    .header("Authorization", "Bearer " + token)
    .GET().build();
System.out.println(client.send(req, HttpResponse.BodyHandlers.ofString()).body());

// Send an email
var body = """
    {"to":[{"email":"recipient@example.com"}],
     "subject":"Hello from Java",
     "body":"<p>Sent via SyncGaze API</p>"}
    """;
var send = HttpRequest.newBuilder()
    .uri(URI.create(api + "/send/"))
    .header("Authorization", "Bearer " + token)
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(body)).build();
System.out.println(client.send(send, HttpResponse.BodyHandlers.ofString()).statusCode());

using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

var api   = "https://mail.syncgaze.in/api/v1/webmail";
var http  = new HttpClient();
http.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", "sg_YOUR_TOKEN");

// List folders
Console.WriteLine(await http.GetStringAsync($"{api}/folders/"));

// List INBOX messages
Console.WriteLine(await http.GetStringAsync(
    $"{api}/messages/?folder=INBOX&limit=20"));

// Send an email
var payload = """
    {"to":[{"email":"recipient@example.com"}],
     "subject":"Hello from C#",
     "body":"<p>Sent via SyncGaze API</p>"}
    """;
var resp = await http.PostAsync($"{api}/send/",
    new StringContent(payload, Encoding.UTF8, "application/json"));
Console.WriteLine((int)resp.StatusCode);

// Cargo.toml:  reqwest = { version = "0.12", features = ["json","blocking"] }
//              serde_json = "1"
use reqwest::blocking::Client;
use serde_json::json;

fn main() -> Result<(), reqwest::Error> {
    let api    = "https://mail.syncgaze.in/api/v1/webmail";
    let token  = "sg_YOUR_TOKEN";
    let client = Client::new();
    let auth   = format!("Bearer {token}");

    // List folders
    let folders = client.get(format!("{api}/folders/"))
        .header("Authorization", &auth).send()?.text()?;
    println!("{folders}");

    // Send an email
    let r = client.post(format!("{api}/send/"))
        .header("Authorization", &auth)
        .json(&json!({
            "to":      [{ "email": "recipient@example.com" }],
            "subject": "Hello from Rust",
            "body":    "<p>Sent via SyncGaze API</p>",
        })).send()?;
    println!("{}", r.status());
    Ok(())
}

import Foundation

let api   = "https://mail.syncgaze.in/api/v1/webmail"
let token = "sg_YOUR_TOKEN"

func sg(_ path: String, method: String = "GET", body: Data? = nil) async throws -> Data {
    var req = URLRequest(url: URL(string: api + path)!)
    req.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
    req.httpMethod = method
    if let b = body {
        req.httpBody = b
        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    }
    let (data, _) = try await URLSession.shared.data(for: req)
    return data
}

// List folders
let folders = try await sg("/folders/")
print(String(data: folders, encoding: .utf8)!)

// Send an email
let payload = try! JSONSerialization.data(withJSONObject: [
    "to": [["email": "recipient@example.com"]],
    "subject": "Hello from Swift",
    "body": "<p>Sent via SyncGaze API</p>",
])
let result = try await sg("/send/", method: "POST", body: payload)
print(String(data: result, encoding: .utf8)!)

// build.gradle: implementation("com.squareup.okhttp3:okhttp:4.12.0")
import okhttp3.*; import okhttp3.MediaType.Companion.toMediaType

val api    = "https://mail.syncgaze.in/api/v1/webmail"
val token  = "sg_YOUR_TOKEN"
val client = OkHttpClient()
val JSON   = "application/json".toMediaType()

// List folders
val req = Request.Builder()
    .url("$api/folders/")
    .header("Authorization", "Bearer $token")
    .build()
client.newCall(req).execute().use { println(it.body!!.string()) }

// Send an email
val body = RequestBody.create(JSON, """
    {"to":[{"email":"recipient@example.com"}],
     "subject":"Hello from Kotlin",
     "body":"<p>Sent via SyncGaze API</p>"}
""")
val send = Request.Builder()
    .url("$api/send/")
    .header("Authorization", "Bearer $token")
    .post(body).build()
client.newCall(send).execute().use { println(it.code) }

// npm install axios
import axios, { AxiosError } from "axios";

const API_URL = "https://mail.syncgaze.in/api/v1/webmail";
const TOKEN   = "sg_YOUR_TOKEN";

interface Folder  { name: string; flags: string[] }
interface Message { uid: number; subject: string; from: string; date: string }

const client = axios.create({
  baseURL: API_URL,
  headers: { Authorization: `Bearer ${TOKEN}` },
});

// List folders
const { data: folders } = await client.get<Folder[]>("/folders/");
console.log(folders);

// List INBOX messages
const { data: messages } = await client.get<Message[]>(
  "/messages/",
  { params: { folder: "INBOX", limit: 20 } }
);
console.log(messages);

// Send an email
try {
  const { data, status } = await client.post("/send/", {
    to:      [{ email: "recipient@example.com" }],
    subject: "Hello from TypeScript",
    body:    "<p>Sent via SyncGaze API</p>",
  });
  console.log(status, data);
} catch (err) {
  const e = err as AxiosError;
  console.error(e.response?.status, e.response?.data);
}

# pip install fastapi aiohttp uvicorn
import aiohttp
from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

API_URL = "https://mail.syncgaze.in/api/v1/webmail"
TOKEN   = "sg_YOUR_TOKEN"
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}


@app.get("/list-folders")
async def list_folders():
    async with aiohttp.ClientSession() as session:
        try:
            async with session.get(f"{API_URL}/folders/", headers=HEADERS) as resp:
                if resp.status != 200:
                    raise HTTPException(status_code=resp.status, detail=await resp.text())
                return await resp.json()
        except aiohttp.ClientError as exc:
            raise HTTPException(status_code=503, detail=str(exc))


@app.post("/send-email", status_code=201)
async def send_email():
    # Send an email
    payload = {
        "to":      [{"email": "recipient@example.com"}],
        "subject": "Hello from FastAPI",
        "body":    "<p>Sent via SyncGaze API</p>",
    }
    async with aiohttp.ClientSession() as session:
        try:
            async with session.post(
                f"{API_URL}/send/", headers=HEADERS, json=payload
            ) as resp:
                data = await resp.json()
                if resp.status not in (200, 201):
                    raise HTTPException(status_code=resp.status, detail=data)
                return JSONResponse(content=data, status_code=201)
        except aiohttp.ClientError as exc:
            raise HTTPException(status_code=503, detail=str(exc))

// pubspec.yaml:  http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

const apiUrl = 'https://mail.syncgaze.in/api/v1/webmail';
const token  = 'sg_YOUR_TOKEN';
final headers = {
  'Authorization': 'Bearer $token',
  'Content-Type':  'application/json',
};

Future<void> main() async {
  // List folders
  try {
    final res = await http.get(
      Uri.parse('$apiUrl/folders/'), headers: headers);
    print(jsonDecode(res.body));
  } catch (e) { print('Error: $e'); }

  // List INBOX messages
  try {
    final res = await http.get(
      Uri.parse('$apiUrl/messages/?folder=INBOX&limit=20'),
      headers: headers,
    );
    print(jsonDecode(res.body));
  } catch (e) { print('Error: $e'); }

  // Send an email
  try {
    final res = await http.post(
      Uri.parse('$apiUrl/send/'),
      headers: headers,
      body: jsonEncode({
        'to':      [{ 'email': 'recipient@example.com' }],
        'subject': 'Hello from Dart',
        'body':    '<p>Sent via SyncGaze API</p>',
      }),
    );
    print('${res.statusCode}: ${res.body}');
  } catch (e) { print('Error: $e'); }
}