Un singur API.
Toate serviciile pe care le folosești.

// LLM (compatibil OpenAI SDK)
import OpenAI from "openai";
const client = new OpenAI({
  apiKey: "sk-XXX",
  baseURL: "https://mobinapi.com/api/llm",
});
const r = await client.chat.completions.create({
  model: "claude-sonnet-4-5",
  messages: [{ role: "user", content: "Salut!" }],
});

// Wikidata search
const wd = await fetch(
  "https://mobinapi.com/api/wikidata/search?q=Einstein",
  { headers: { Authorization: "Bearer sk-XXX" } }
).then((r) => r.json());

// Weather Bucharest
const w = await fetch(
  "https://mobinapi.com/api/weather?lat=44.43&lon=26.10",
  { headers: { Authorization: "Bearer sk-XXX" } }
).then((r) => r.json());

import requests

BASE = "https://mobinapi.com"
HEADERS = {"Authorization": "Bearer sk-XXX"}

# LLM (OpenAI SDK style)
from openai import OpenAI
client = OpenAI(api_key="sk-XXX", base_url=f"{BASE}/api/llm")
r = client.chat.completions.create(
    model="claude-sonnet-4-5",
    messages=[{"role": "user", "content": "Salut!"}]
)

# Currency
r = requests.get(
    f"{BASE}/api/currency",
    params={"from": "EUR", "to": "RON", "amount": 100},
    headers=HEADERS
).json()
print(r["converted"]["RON"])

package main

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

const (
    BASE   = "https://mobinapi.com"
    APIKEY = "sk-XXX"
)

func main() {
    // LLM chat
    body, _ := json.Marshal(map[string]any{
        "model": "claude-haiku-4-5",
        "messages": []map[string]string{
            {"role": "user", "content": "Salut!"},
        },
    })
    req, _ := http.NewRequest("POST", BASE+"/api/llm/chat/completions", bytes.NewReader(body))
    req.Header.Set("Authorization", "Bearer "+APIKEY)
    req.Header.Set("Content-Type", "application/json")

    res, _ := http.DefaultClient.Do(req)
    defer res.Body.Close()
    out, _ := io.ReadAll(res.Body)
    fmt.Println(string(out))

    // Geocode
    req2, _ := http.NewRequest("GET", BASE+"/api/geo/search?q=Bucharest", nil)
    req2.Header.Set("Authorization", "Bearer "+APIKEY)
    res2, _ := http.DefaultClient.Do(req2)
    defer res2.Body.Close()
    out2, _ := io.ReadAll(res2.Body)
    fmt.Println(string(out2))
}

// Cargo.toml: reqwest = { version = "0.12", features = ["json"] }
//             serde_json = "1"
//             tokio = { version = "1", features = ["full"] }

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

const BASE: &str = "https://mobinapi.com";
const APIKEY: &str = "sk-XXX";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();

    // LLM
    let res = client.post(format!("{}/api/llm/chat/completions", BASE))
        .bearer_auth(APIKEY)
        .json(&json!({
            "model": "claude-haiku-4-5",
            "messages": [{"role": "user", "content": "Salut!"}]
        }))
        .send().await?
        .json::<serde_json::Value>().await?;
    println!("{:#?}", res);

    // Weather
    let w = client.get(format!("{}/api/weather?lat=44.43&lon=26.10", BASE))
        .bearer_auth(APIKEY)
        .send().await?
        .json::<serde_json::Value>().await?;
    println!("{:#?}", w);

    Ok(())
}

<?php
$BASE = 'https://mobinapi.com';
$APIKEY = 'sk-XXX';

function mobinApi($method, $path, $body = null) {
    global $BASE, $APIKEY;
    $ch = curl_init($BASE . $path);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_CUSTOMREQUEST => $method,
        CURLOPT_HTTPHEADER => [
            'Authorization: Bearer ' . $APIKEY,
            'Content-Type: application/json',
        ],
    ]);
    if ($body !== null) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
    }
    $res = curl_exec($ch);
    curl_close($ch);
    return json_decode($res, true);
}

// LLM
$reply = mobinApi('POST', '/api/llm/chat/completions', [
    'model' => 'claude-haiku-4-5',
    'messages' => [['role' => 'user', 'content' => 'Salut!']],
]);
echo $reply['choices'][0]['message']['content'];

// Currency
$rate = mobinApi('GET', '/api/currency?from=EUR&to=RON&amount=100');
echo "100 EUR = " . $rate['converted']['RON'] . " RON\n";

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

BASE = 'https://mobinapi.com'
APIKEY = 'sk-XXX'

def mobin_api(method, path, body = nil)
  uri = URI("#{BASE}#{path}")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  req = case method
        when :get then Net::HTTP::Get.new(uri)
        when :post then Net::HTTP::Post.new(uri)
        end
  req['Authorization'] = "Bearer #{APIKEY}"
  req['Content-Type'] = 'application/json'
  req.body = body.to_json if body

  JSON.parse(http.request(req).body)
end

# LLM
reply = mobin_api(:post, '/api/llm/chat/completions', {
  model: 'claude-haiku-4-5',
  messages: [{ role: 'user', content: 'Salut!' }]
})
puts reply['choices'][0]['message']['content']

# Wikipedia
wiki = mobin_api(:get, '/api/wikipedia/Albert_Einstein')
puts wiki['extract']

// Java 11+ HttpClient (zero-dependency)
import java.net.URI;
import java.net.http.*;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse.BodyHandlers;

public class MobinApi {
    static final String BASE = "https://mobinapi.com";
    static final String APIKEY = "sk-XXX";
    static final HttpClient client = HttpClient.newHttpClient();

    public static void main(String[] args) throws Exception {
        // LLM
        String body = """
            {
              "model": "claude-haiku-4-5",
              "messages": [{"role":"user","content":"Salut!"}]
            }
            """;
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(BASE + "/api/llm/chat/completions"))
            .header("Authorization", "Bearer " + APIKEY)
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> res = client.send(req, BodyHandlers.ofString());
        System.out.println(res.body());

        // Wikidata search
        HttpRequest req2 = HttpRequest.newBuilder()
            .uri(URI.create(BASE + "/api/wikidata/search?q=Einstein"))
            .header("Authorization", "Bearer " + APIKEY)
            .GET()
            .build();
        System.out.println(client.send(req2, BodyHandlers.ofString()).body());
    }
}

# 1. Catalog public
curl https://mobinapi.com/api/services

# 2. LLM
curl -X POST https://mobinapi.com/api/llm/chat/completions \
  -H "Authorization: Bearer sk-XXX" \
  -H "Content-Type: application/json" \
  -d '{"model":"claude-haiku-4-5","messages":[{"role":"user","content":"hi"}]}'

# 3. Wikidata
curl "https://mobinapi.com/api/wikidata/search?q=Einstein" \
  -H "Authorization: Bearer sk-XXX"

# 4. Geo
curl "https://mobinapi.com/api/geo/search?q=Bucharest" \
  -H "Authorization: Bearer sk-XXX"

# 5. Weather
curl "https://mobinapi.com/api/weather?lat=44.43&lon=26.10" \
  -H "Authorization: Bearer sk-XXX"

# 6. Currency
curl "https://mobinapi.com/api/currency?from=EUR&to=RON" \
  -H "Authorization: Bearer sk-XXX"

# 7. IP geolocation
curl "https://mobinapi.com/api/ip/8.8.8.8" \
  -H "Authorization: Bearer sk-XXX"

Content-Type: application/json
User-Agent: MobinApi-Webhooks/1.0
X-MobinApi-Event: budget_threshold       # tipul evenimentului
X-MobinApi-Signature: sha256=<hex>       # HMAC-SHA256 al body-ului
X-MobinApi-Attempt: 1                    # 1..4 (retries cu exponential backoff)

{
  "event": "budget_threshold",
  "timestamp": "2026-05-08T12:34:56.000Z",
  "key_token_prefix": "sk-virtual-x",
  "message": "Workspace key reached 80% of monthly budget",
  "current_spend": 80.50,
  "max_budget": 100.00
}

import crypto from "node:crypto";

export function verifyMobinApiSignature(
  body: string,
  signature: string | null,
  secret: string
): boolean {
  if (!signature || !signature.startsWith("sha256=")) return false;
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  // Constant-time compare ca să eviți timing attacks
  const provided = signature.slice("sha256=".length);
  if (provided.length !== expected.length) return false;
  return crypto.timingSafeEqual(
    Buffer.from(provided),
    Buffer.from(expected)
  );
}

// În handler-ul tău Express/Fastify:
app.post("/webhooks/mobinapi", async (req, res) => {
  const signature = req.headers["x-mobinapi-signature"];
  const rawBody = req.rawBody;  // sau JSON.stringify(req.body) dacă nu ai raw

  if (!verifyMobinApiSignature(rawBody, signature, process.env.WEBHOOK_SECRET)) {
    return res.status(401).send("Invalid signature");
  }

  const event = JSON.parse(rawBody);
  console.log("Verified event:", event.event, event.message);
  res.status(200).send("OK");
});

import hmac
import hashlib

def verify_signature(body: bytes, signature: str | None, secret: str) -> bool:
    if not signature or not signature.startswith("sha256="):
        return False
    expected = hmac.new(
        secret.encode(), body, hashlib.sha256
    ).hexdigest()
    provided = signature[len("sha256="):]
    return hmac.compare_digest(provided, expected)

# În FastAPI:
from fastapi import FastAPI, Request, HTTPException

app = FastAPI()

@app.post("/webhooks/mobinapi")
async def mobinapi_webhook(request: Request):
    body = await request.body()
    signature = request.headers.get("x-mobinapi-signature")

    if not verify_signature(body, signature, os.environ["WEBHOOK_SECRET"]):
        raise HTTPException(401, "Invalid signature")

    event = json.loads(body)
    print(f"Verified: {event['event']} — {event['message']}")
    return {"ok": True}

// Înainte (OpenRouter):
import OpenAI from "openai";
const openrouter = new OpenAI({
  apiKey: "sk-or-v1-...",
  baseURL: "https://openrouter.ai/api/v1",
});

// După (MobinApi):
const mobinapi = new OpenAI({
  apiKey: "sk-virtual-key-xxx",
  baseURL: "https://mobinapi.com/api/llm",  // ← single change
});

// Apoi:
const r = await mobinapi.chat.completions.create({
  model: "claude-sonnet-4-5",  // sau "gpt-4o", "grok-2", etc.
  messages: [{ role: "user", content: "Salut!" }],
});

Compatibilitate 100% OpenAI SDK — același cod funcționează.

// Înainte: chei separate pentru fiecare provider
const anthropic = new Anthropic({ apiKey: "sk-ant-..." });
const openai = new OpenAI({ apiKey: "sk-..." });
const xai = ...;

// Plus: chei separate pentru utility APIs
const weather = await fetch("https://api.openweathermap.org/...");
const geocode = await fetch("https://api.opencagedata.com/...");
// ...etc

// După: o singură cheie MobinApi pentru TOATE
const KEY = "sk-virtual-key-xxx";
const headers = { Authorization: `Bearer ${KEY}` };

const ai = new OpenAI({ apiKey: KEY, baseURL: "https://mobinapi.com/api/llm" });
const w = await fetch("https://mobinapi.com/api/weather?lat=44.43&lon=26.10", { headers });
const geo = await fetch("https://mobinapi.com/api/geo/search?q=Bucharest", { headers });
const wiki = await fetch("https://mobinapi.com/api/wikipedia/Albert_Einstein", { headers });
// ...
// O cheie, audit unificat, billing unificat, rate limits unificate.

// RapidAPI requires X-RapidAPI-Host + X-RapidAPI-Key per API
// MobinApi: o singură cheie, header standard

// Înainte (RapidAPI):
fetch("https://wikidata-search.p.rapidapi.com/search", {
  headers: {
    "X-RapidAPI-Key": "...",
    "X-RapidAPI-Host": "wikidata-search.p.rapidapi.com"
  }
});

// După (MobinApi):
fetch("https://mobinapi.com/api/wikidata/search?q=Einstein", {
  headers: { Authorization: "Bearer sk-virtual-key-xxx" }
});

Avantaj: nu mai gestionezi N chei + audit unificat. Limitare actuală: catalog mai mic decât 10k+ API-uri RapidAPI.