Ship your app. Build the backend. Skip it.

import axios from "axios";
const api = axios.create({ baseURL: "https://api.eazemyapi.com/myblog", headers: { "X-API-SIGNATURE": process.env.API_KEY } });

const { data } = await api.get("/posts/v1/list");
if (data.success) console.log(data.data);

await api.post("/posts/v1/create", { title: "Hello", content: "World", is_published: true });
await api.post("/posts/v1/update/1", { title: "Updated" });
await api.delete("/posts/v1/delete/1");

import { useState, useEffect } from "react";

export default function Posts() {
  const [posts, setPosts] = useState([]);

  useEffect(() => {
    fetch("/api/proxy?path=posts/v1/list")
      .then(r => r.json())
      .then(({ success, data }) => success && setPosts(data));
  }, []);

  return <ul>{posts.map(p => <li key={p.id}>{p.title}</li>)}</ul>;
}

// pages/api/proxy.js
export default async function handler(req, res) {
  const { path, ...params } = req.query;
  const url = `https://api.eazemyapi.com/myblog/${path}${new URLSearchParams(params).toString() ? "?" + new URLSearchParams(params) : ""}`;
  const r = await fetch(url, {
    method: req.method,
    headers: { "Content-Type": "application/json", "X-API-SIGNATURE": process.env.EAZE_API_KEY },
    body: req.method === "POST" ? JSON.stringify(req.body) : undefined
  });
  res.status(r.status).json(await r.json());
}

import { ref, onMounted } from "vue";
export default {
  setup() {
    const posts = ref([]);
    onMounted(async () => {
      const res = await fetch("https://api.eazemyapi.com/myblog/posts/v1/list",
        { headers: { "X-API-SIGNATURE": import.meta.env.VITE_API_KEY } });
      const { success, data } = await res.json();
      if (success) posts.value = data;
    });
    return { posts };
  }
};

import { Injectable } from "@angular/core";
import { HttpClient, HttpHeaders } from "@angular/common/http";

@Injectable({ providedIn: "root" })
export class PostsService {
  private base = "https://api.eazemyapi.com/myblog";
  private h = new HttpHeaders({ "X-API-SIGNATURE": environment.apiKey });
  constructor(private http: HttpClient) {}
  list() { return this.http.get(`${this.base}/posts/v1/list`, { headers: this.h }); }
  create(p: any) { return this.http.post(`${this.base}/posts/v1/create`, p, { headers: this.h }); }
  update(id: number, p: any) { return this.http.post(`${this.base}/posts/v1/update/${id}`, p, { headers: this.h }); }
  remove(id: number) { return this.http.delete(`${this.base}/posts/v1/delete/${id}`, { headers: this.h }); }
}

interface Post { id: number; title: string; content: string; is_published: boolean; created_at: string; }
interface ApiResponse<T> { success: boolean; message: string; data: T; }

const BASE = "https://api.eazemyapi.com/myblog";
const H = { "X-API-SIGNATURE": process.env.API_KEY! };

async function listPosts(): Promise<Post[]> {
  const r = await fetch(`${BASE}/posts/v1/list`, { headers: H });
  const json: ApiResponse<Post[]> = await r.json();
  return json.success ? json.data : [];
}

async function createPost(post: Omit<Post, "id"|"created_at">): Promise<Post> {
  const r = await fetch(`${BASE}/posts/v1/create`, {
    method: "POST", headers: { ...H, "Content-Type": "application/json" }, body: JSON.stringify(post)
  });
  return (await r.json()).data;
}

import { useState, useEffect } from "react";
import { FlatList, Text, View } from "react-native";

export default function Posts() {
  const [posts, setPosts] = useState([]);
  useEffect(() => {
    fetch("https://api.eazemyapi.com/myblog/posts/v1/list",
      { headers: { "X-API-SIGNATURE": "YOUR_API_KEY" } })
      .then(r => r.json())
      .then(({ success, data }) => success && setPosts(data));
  }, []);
  return <FlatList data={posts} keyExtractor={i => String(i.id)} renderItem={({ item }) => <View><Text>{item.title}</Text></View>}/>;
}

import requests, os
H = { "X-API-SIGNATURE": os.environ["API_KEY"], "Content-Type": "application/json" }
B = "https://api.eazemyapi.com/myblog"

# List posts
r = requests.get(f"{B}/posts/v1/list", headers=H).json()
if r["success"]: [print(p["title"]) for p in r["data"]]

# Create post
r = requests.post(f"{B}/posts/v1/create", headers=H,
    json={"title": "Hello", "content": "World", "is_published": True}).json()

# Update post
requests.post(f"{B}/posts/v1/update/1", headers=H, json={"title": "New Title"})

# Delete post
requests.delete(f"{B}/posts/v1/delete/1", headers=H)

<?php
$key = $_ENV["API_KEY"]; $base = "https://api.eazemyapi.com/myblog";

function eaze($url, $method = "GET", $body = null) global $key {
  $ch = curl_init($url);
  $headers = ["X-API-SIGNATURE: $key", "Content-Type: application/json"];
  curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER=>true, CURLOPT_CUSTOMREQUEST=>$method,
    CURLOPT_HTTPHEADER=>$headers, CURLOPT_POSTFIELDS=>$body ? json_encode($body) : null]);
  return json_decode(curl_exec($ch), true);
}

$posts  = eaze("$base/posts/v1/list");
$new    = eaze("$base/posts/v1/create", "POST", ["title"=>"Hello", "content"=>"World"]);
$update = eaze("$base/posts/v1/update/1", "POST", ["title"=>"Updated"]);
$del    = eaze("$base/posts/v1/delete/1", "DELETE");

import Foundation
let apiKey = "YOUR_API_KEY"
let base = "https://api.eazemyapi.com/myblog"

var req = URLRequest(url: URL(string: "\(base)/posts/v1/list")!)
req.setValue(apiKey, forHTTPHeaderField: "X-API-SIGNATURE")
URLSession.shared.dataTask(with: req) { data, _, _ in
  if let data, let json = try? JSONSerialization.jsonObject(with: data) as? [String:Any],
     json["success"] as? Bool == true, let posts = json["data"] as? [[String:Any]] {
    posts.forEach { print($0["title"] ?? "") }
  }
}.resume()

val client = OkHttpClient()
val base = "https://api.eazemyapi.com/myblog"
val key = "YOUR_API_KEY"

// List posts
val req = Request.Builder().url("$base/posts/v1/list").header("X-API-SIGNATURE", key).build()
client.newCall(req).execute().use { res ->
  val json = JSONObject(res.body?.string() ?: "")
  if (json.getBoolean("success")) println(json.getJSONArray("data"))
}

// Create post
val body = """{"title":"Hello","content":"World","is_published":true}"""
  .toRequestBody("application/json".toMediaType())
val createReq = Request.Builder().url("$base/posts/v1/create")
  .header("X-API-SIGNATURE", key).post(body).build()
client.newCall(createReq).execute().use { res -> println(res.body?.string()) }

var client = HttpClient.newHttpClient();
var key = System.getenv("API_KEY");
var base = "https://api.eazemyapi.com/myblog";

// List posts
var req = HttpRequest.newBuilder().uri(URI.create(base + "/posts/v1/list"))
  .header("X-API-SIGNATURE", key).GET().build();
var res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

// Create post
var json = """{"title":"Hello","content":"World","is_published":true}""";
var createReq = HttpRequest.newBuilder().uri(URI.create(base + "/posts/v1/create"))
  .header("X-API-SIGNATURE", key).header("Content-Type", "application/json")
  .POST(HttpRequest.BodyPublishers.ofString(json)).build();
System.out.println(client.send(createReq, HttpResponse.BodyHandlers.ofString()).body());

import 'dart:convert';
import 'package:http/http.dart' as http;

const base = 'https://api.eazemyapi.com/myblog';
final headers = { 'X-API-SIGNATURE': 'YOUR_KEY', 'Content-Type': 'application/json' };

Future<void> main() async {
  // List posts
  var r = await http.get(Uri.parse('$base/posts/v1/list'), headers: headers);
  var json = jsonDecode(r.body);
  if (json['success']) print(json['data']);

  // Create post
  await http.post(Uri.parse('$base/posts/v1/create'), headers: headers,
    body: jsonEncode({'title': 'Hello', 'content': 'World', 'is_published': true}));
}

package main
import ("bytes"; "encoding/json"; "fmt"; "net/http"; "os")

func eaze(method, path string, body any) map[string]any {
  var buf *bytes.Buffer
  if body != nil { b, _ := json.Marshal(body); buf = bytes.NewBuffer(b) } else { buf = &bytes.Buffer{} }
  req, _ := http.NewRequest(method, "https://api.eazemyapi.com/myblog"+path, buf)
  req.Header.Set("X-API-SIGNATURE", os.Getenv("API_KEY"))
  req.Header.Set("Content-Type", "application/json")
  resp, _ := http.DefaultClient.Do(req); defer resp.Body.Close()
  var result map[string]any; json.NewDecoder(resp.Body).Decode(&result); return result
}

func main() {
  fmt.Println(eaze("GET", "/posts/v1/list", nil))
  fmt.Println(eaze("POST", "/posts/v1/create", map[string]any{"title":"Hello","content":"World"}))
}

require "net/http"; require "json"
BASE = "https://api.eazemyapi.com/myblog"; KEY = ENV["API_KEY"]

def eaze(method, path, body = nil)
  uri = URI("#{BASE}#{path}")
  req = Net::HTTP.const_get(method.capitalize).new(uri)
  req["X-API-SIGNATURE"] = KEY; req["Content-Type"] = "application/json"
  req.body = body.to_json if body
  Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| JSON.parse(h.request(req).body) }
end

posts = eaze("get", "/posts/v1/list")
eaze("post", "/posts/v1/create", { title: "Hello", content: "World", is_published: true })
eaze("post", "/posts/v1/update/1", { title: "Updated" })
eaze("delete", "/posts/v1/delete/1")

using System.Net.Http; using System.Text; using System.Text.Json;
var client = new HttpClient(); var base_ = "https://api.eazemyapi.com/myblog";
client.DefaultRequestHeaders.Add("X-API-SIGNATURE", Environment.GetEnvironmentVariable("API_KEY")!);

// List posts
var r = await client.GetAsync($"{base_}/posts/v1/list");
var json = JsonDocument.Parse(await r.Content.ReadAsStringAsync()).RootElement;
if (json.GetProperty("success").GetBoolean())
  foreach (var p in json.GetProperty("data").EnumerateArray())
    Console.WriteLine(p.GetProperty("title").GetString());

// Create post
var payload = new StringContent(JsonSerializer.Serialize(new { title="Hello", content="World", is_published=true }), Encoding.UTF8, "application/json");
Console.WriteLine(await (await client.PostAsync($"{base_}/posts/v1/create", payload)).Content.ReadAsStringAsync());

# List all posts
curl "https://api.eazemyapi.com/myblog/posts/v1/list" -H "X-API-SIGNATURE: YOUR_KEY"

# Create a post
curl -X POST "https://api.eazemyapi.com/myblog/posts/v1/create" \
  -H "X-API-SIGNATURE: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"title":"Hello","content":"World","is_published":true}'

# Update a post
curl -X POST "https://api.eazemyapi.com/myblog/posts/v1/update/1" \
  -H "X-API-SIGNATURE: YOUR_KEY" -H "Content-Type: application/json" \
  -d '{"title":"Updated Title"}'

# Delete a post
curl -X DELETE "https://api.eazemyapi.com/myblog/posts/v1/delete/1" -H "X-API-SIGNATURE: YOUR_KEY"

{
  "success": true,
  "message": "Data found.",
  "data": [
    { "id": 1, "title": "Hello", "content": "World", "is_published": true, "created_at": "2026-04-10T10:00:00Z" }
  ]
}

// Always check success before using data
// success: false → check message for the reason