<?php
$endpoint = 'https://pixi.mg/api';
$filePath = __DIR__ . '/image.png';

$ch = curl_init($endpoint);

$postFields = [
    'file' => new CURLFile($filePath, 'image/png', 'image.png'),
];

curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POSTFIELDS     => $postFields,
]);

$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException('cURL error: ' . curl_error($ch));
}
curl_close($ch);

$data = json_decode($response, true);
if (!($data['success'] ?? false)) {
    var_dump($data);
    exit("Upload failed\n");
}

echo "Direct URL: " . $data['direct_url'] . PHP_EOL;
echo "Delete URL: " . $data['delete_url'] . PHP_EOL;

// Node.js example (using node-fetch & form-data)
import fetch from 'node-fetch';
import FormData from 'form-data';
import fs from 'fs';

const endpoint = 'https://pixi.mg/api';
const form = new FormData();

form.append('file', fs.createReadStream('./image.png'));

const res = await fetch(endpoint, {
  method: 'POST',
  body: form,
});

const data = await res.json();

if (!data.success) {
  console.error('Upload failed:', data);
} else {
  console.log('Direct URL:', data.direct_url);
  console.log('Delete URL:', data.delete_url);
}

import requests

endpoint = "https://pixi.mg/api"
files = {
    "file": ("image.png", open("image.png", "rb"), "image/png")
}

resp = requests.post(endpoint, files=files)
data = resp.json()

if not data.get("success"):
    print("Upload failed:", data)
else:
    print("Direct URL:", data["direct_url"])
    print("Delete URL:", data["delete_url"])

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    filePath := "image.png"
    endpoint := "https://pixi.mg/api"

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    file, err := os.Open(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    part, err := writer.CreateFormFile("file", "image.png")
    if err != nil {
        panic(err)
    }
    if _, err = io.Copy(part, file); err != nil {
        panic(err)
    }

    writer.Close()

    req, err := http.NewRequest("POST", endpoint, body)
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", writer.FormDataContentType())

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    respBody, _ := io.ReadAll(resp.Body)
    fmt.Println(string(respBody))
}

use reqwest::blocking::Client;
use reqwest::blocking::multipart;
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box> {
    let endpoint = "https://pixi.mg/api";

    let mut file = File::open("image.png")?;
    let mut buf = Vec::new();
    file.read_to_end(&mut buf)?;

    let part = multipart::Part::bytes(buf)
        .file_name("image.png")
        .mime_str("image/png")?;

    let form = multipart::Form::new().part("file", part);

    let client = Client::new();
    let resp = client.post(endpoint).multipart(form).send()?;

    let text = resp.text()?;
    println!("{}", text);

    Ok(())
}