API reference

Programmatic access to your ReacTok account: manage products, avatars and saved reactions, generate reaction videos, and publish to your connected channels. The API exposes the same capabilities as the web studio, scoped to the account that owns the key.

Introduction

The base URL for all requests is:

https://your-host/api/v1

Local development (WAMP subfolder): http://localhost/easyugcai/public/api/v1

All requests and responses are JSON. Replace your-host in the examples with your domain, and set an EUGC_KEY environment variable to your API key.

A quick liveness check needs no key: GET / returns the API name and version.

Authentication

Create a key in the app under Settings → API access. Send it as a Bearer token on every request:

Authorization: Bearer eugc_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

The raw key is shown once at creation. Store it securely.
Revoke a key anytime in Settings; revoked keys stop working immediately.
First-party browser calls may instead rely on the logged-in session cookie.

Set your key once in the shell or environment:

export EUGC_KEY="eugc_your_key_here"

import os
EUGC_KEY = os.environ["EUGC_KEY"]

// .env
EUGC_KEY=eugc_your_key_here

<?php $EUGC_KEY = getenv('EUGC_KEY');

EUGC_KEY := os.Getenv("EUGC_KEY")

String EUGC_KEY = System.getenv("EUGC_KEY");

EUGC_KEY = ENV["EUGC_KEY"]

Conventions

Bodies may be JSON (Content-Type: application/json) or form-encoded. File uploads use multipart/form-data.
Success: 2xx with { "data": ... }.
Pagination: paginated lists (products, videos, social/posts) accept ?page=1&per_page=20 (max per_page is 100) and add { "meta": { "page", "per_page", "total" } }. Smaller collections (avatars, reactions) return the full set with no meta.

Errors

Errors return a non-2xx status with a JSON body:

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

{ "error": "Product not found.", "code": "not_found" }

Status	Code	Meaning
`400`	bad_request	Missing or invalid parameters.
`401`	unauthorized	Missing, malformed, or revoked API key.
`403`	forbidden	The key cannot access this resource.
`404`	not_found	Resource does not exist.
`409`	conflict	State conflict (e.g. approving a non-preview job).
`429`	rate_limited	Too many requests. Retry after a moment.

Rate limits

A coarse per-account limit of 120 requests/minute applies to all endpoints (429, code: rate_limited). AI helpers (hook generation and avatar generation) have additional daily and burst backstops to keep costs predictable.

The generation flow

Generating a video is asynchronous with an optional human-in-the-loop step. Each finished video consumes one monthly allowance — including a reused saved reaction. Regenerating a preview consumes another; finalizing an already-charged preview does not.

One-shot (default). POST /videos enqueues the job and the worker runs the whole pipeline automatically. Poll GET /videos/jobs/{id} until status is done, then fetch the video.

Preview mode. POST /videos with mode=preview pauses after the reaction clip is generated (status: preview_ready). Then call approve to finalize, or regenerate to re-roll.

Products

Your products are the subject of every reaction video.

GET /products

List your products (paginated).

curl -X GET "https://your-host/api/v1/products" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/products",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/products", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/products");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/products", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/products"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/products")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /products

Create a product.

Field	Type	Required	Description
`name`	string	yes	Product name.
`description`	string	no	Short description used to steer generations.
`demo_video`	file	no	Optional MP4/AVI/MOV, vertical, ≤50MB (multipart only).

To attach a demo video, send multipart/form-data instead of JSON: curl -X POST .../products -H "Authorization: Bearer $EUGC_KEY" -F "name=Cal AI" -F "demo_video=@demo.mp4"

curl -X POST "https://your-host/api/v1/products" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"Cal AI","description":"AI calorie tracking from a photo."}'

import requests

res = requests.post(
    "https://your-host/api/v1/products",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"name": "Cal AI", "description": "AI calorie tracking from a photo."},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/products", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"name":"Cal AI","description":"AI calorie tracking from a photo."}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/products");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['name' => 'Cal AI', 'description' => 'AI calorie tracking from a photo.']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"name":"Cal AI","description":"AI calorie tracking from a photo."}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/products", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/products"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"name\":\"Cal AI\",\"description\":\"AI calorie tracking from a photo.\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/products")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {name: "Cal AI", description: "AI calorie tracking from a photo."}.to_json
res = http.request(req)
puts res.body

GET /products/{id}

Fetch a single product.

curl -X GET "https://your-host/api/v1/products/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/products/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/products/1", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/products/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/products/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/products/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/products/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

PATCH /products/{id}

Update a product. (PUT is also accepted.)

Field	Type	Required	Description
`name`	string	no	New name.
`description`	string	no	New description.

curl -X PATCH "https://your-host/api/v1/products/1" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"description":"Updated description."}'

import requests

res = requests.patch(
    "https://your-host/api/v1/products/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"description": "Updated description."},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/products/1", {
  method: "PATCH",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"description":"Updated description."}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/products/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['description' => 'Updated description.']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"description":"Updated description."}`)
	req, _ := http.NewRequest("PATCH", "https://your-host/api/v1/products/1", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/products/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\"description\":\"Updated description.\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/products/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Patch.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {description: "Updated description."}.to_json
res = http.request(req)
puts res.body

DELETE /products/{id}

Delete a product.

curl -X DELETE "https://your-host/api/v1/products/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.delete(
    "https://your-host/api/v1/products/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/products/1", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/products/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://your-host/api/v1/products/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/products/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/products/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

Avatars

Avatars are the on-screen creators. Upload your own image or generate one from a text prompt.

GET /avatars

List your avatars.

curl -X GET "https://your-host/api/v1/avatars" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/avatars",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/avatars", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/avatars");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/avatars", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/avatars"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/avatars")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /avatars

Create an avatar by generating one from a prompt. (Rate limited.)

Field	Type	Required	Description
`prompt`	string	yes	Description of the person to generate.
`image`	file	no	Alternatively, upload an image (JPG/PNG/WEBP, ≥340×340, ≤10MB) via multipart.

To upload an image instead: curl -X POST .../avatars -H "Authorization: Bearer $EUGC_KEY" -F "image=@face.jpg"

curl -X POST "https://your-host/api/v1/avatars" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"friendly woman in her 20s, soft studio lighting, plain background"}'

import requests

res = requests.post(
    "https://your-host/api/v1/avatars",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"prompt": "friendly woman in her 20s, soft studio lighting, plain background"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/avatars", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"prompt":"friendly woman in her 20s, soft studio lighting, plain background"}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/avatars");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['prompt' => 'friendly woman in her 20s, soft studio lighting, plain background']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"prompt":"friendly woman in her 20s, soft studio lighting, plain background"}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/avatars", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/avatars"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"prompt\":\"friendly woman in her 20s, soft studio lighting, plain background\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/avatars")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {prompt: "friendly woman in her 20s, soft studio lighting, plain background"}.to_json
res = http.request(req)
puts res.body

GET /avatars/{id}

Fetch a single avatar.

curl -X GET "https://your-host/api/v1/avatars/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/avatars/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/avatars/1", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/avatars/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/avatars/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/avatars/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/avatars/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

DELETE /avatars/{id}

Delete an avatar.

curl -X DELETE "https://your-host/api/v1/avatars/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.delete(
    "https://your-host/api/v1/avatars/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/avatars/1", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/avatars/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://your-host/api/v1/avatars/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/avatars/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/avatars/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

Reactions (reuse library)

Saved reaction clips you can reuse on new videos, skipping regeneration (each reused video still consumes one allowance).

GET /reactions

List your saved reactions.

curl -X GET "https://your-host/api/v1/reactions" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/reactions",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/reactions", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/reactions");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/reactions", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/reactions"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/reactions")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /reactions

Save a preview_ready job's reaction to your library for reuse. Idempotent per job; subject to your plan's library cap.

Field	Type	Required	Description
`job_id`	int	yes	A job currently at `preview_ready`.

curl -X POST "https://your-host/api/v1/reactions" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"job_id":42}'

import requests

res = requests.post(
    "https://your-host/api/v1/reactions",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"job_id": 42},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/reactions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"job_id":42}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/reactions");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['job_id' => 42]),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"job_id":42}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/reactions", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/reactions"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"job_id\":42}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/reactions")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {job_id: 42}.to_json
res = http.request(req)
puts res.body

GET /reactions/{id}

Fetch a saved reaction.

curl -X GET "https://your-host/api/v1/reactions/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/reactions/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/reactions/1", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/reactions/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/reactions/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/reactions/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/reactions/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

DELETE /reactions/{id}

Delete a saved reaction.

curl -X DELETE "https://your-host/api/v1/reactions/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.delete(
    "https://your-host/api/v1/reactions/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/reactions/1", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/reactions/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://your-host/api/v1/reactions/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/reactions/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/reactions/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

Videos & jobs

Create generation jobs, poll their status, and manage finished videos. See the generation flow for one-shot vs preview mode.

GET /videos

List finished videos (paginated).

curl -X GET "https://your-host/api/v1/videos" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/videos",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/videos", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/videos")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

GET /videos/{id}

Fetch a finished video (includes a playable url).

curl -X GET "https://your-host/api/v1/videos/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/videos/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos/1", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/videos/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/videos/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

DELETE /videos/{id}

Delete a video.

curl -X DELETE "https://your-host/api/v1/videos/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.delete(
    "https://your-host/api/v1/videos/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos/1", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://your-host/api/v1/videos/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/videos/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /videos

Create a generation job. Each finished video consumes one monthly allowance, including reused reactions; regenerating a preview consumes another.

Field	Type	Required	Description
`product_id`	int	yes	The product to feature.
`method`	string	yes	`prompt`, `motion`, or `reuse`.
`mode`	string	no	`auto` (default, runs end-to-end) or `preview` (pauses for approval).
`hook_text`	string	no	On-screen hook caption (≤100 chars).
`hook_position`	string	no	`top`, `middle`, or `bottom`.
`prompt`	string	no	For `method=prompt`: the reaction description.
`avatar_id`	int	no	For `method=motion`.
`video_source`	string	no	For `method=motion`: `link` or `upload`.
`reference_url`	string	no	For `method=motion` + `link` (TikTok URL).
`reaction_id`	int	no	For `method=reuse`: a saved reaction to reuse.

For method=motion with video_source=upload, send multipart/form-data with the source clip in a reference_video file field:

curl -X POST .../videos -H "Authorization: Bearer $EUGC_KEY" -F "product_id=1" -F "method=motion" -F "avatar_id=5" -F "video_source=upload" -F "reference_video=@clip.mp4"

. Use video_source=link with a reference_url (TikTok) to skip the upload.

curl -X POST "https://your-host/api/v1/videos" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"product_id":1,"method":"prompt","prompt":"excited reaction to a fitness app","hook_text":"this changed my routine","mode":"auto"}'

import requests

res = requests.post(
    "https://your-host/api/v1/videos",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"product_id": 1, "method": "prompt", "prompt": "excited reaction to a fitness app", "hook_text": "this changed my routine", "mode": "auto"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"product_id":1,"method":"prompt","prompt":"excited reaction to a fitness app","hook_text":"this changed my routine","mode":"auto"}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['product_id' => 1, 'method' => 'prompt', 'prompt' => 'excited reaction to a fitness app', 'hook_text' => 'this changed my routine', 'mode' => 'auto']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"product_id":1,"method":"prompt","prompt":"excited reaction to a fitness app","hook_text":"this changed my routine","mode":"auto"}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/videos", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"product_id\":1,\"method\":\"prompt\",\"prompt\":\"excited reaction to a fitness app\",\"hook_text\":\"this changed my routine\",\"mode\":\"auto\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/videos")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {product_id: 1, method: "prompt", prompt: "excited reaction to a fitness app", hook_text: "this changed my routine", mode: "auto"}.to_json
res = http.request(req)
puts res.body

GET /videos/jobs/{id}

Poll a job. status is one of queued, processing, preview_ready, done, failed. When done, video_id is populated.

curl -X GET "https://your-host/api/v1/videos/jobs/42" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/videos/jobs/42",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos/jobs/42", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos/jobs/42");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/videos/jobs/42", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos/jobs/42"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/videos/jobs/42")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /videos/jobs/{id}/approve

Finalize a preview_ready job.

Field	Type	Required	Description
`hook_text`	string	no	Override the hook caption.
`hook_position`	string	no	Override the hook position.

curl -X POST "https://your-host/api/v1/videos/jobs/42/approve" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"hook_text":"this changed my routine"}'

import requests

res = requests.post(
    "https://your-host/api/v1/videos/jobs/42/approve",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"hook_text": "this changed my routine"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos/jobs/42/approve", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"hook_text":"this changed my routine"}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos/jobs/42/approve");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['hook_text' => 'this changed my routine']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"hook_text":"this changed my routine"}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/videos/jobs/42/approve", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos/jobs/42/approve"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"hook_text\":\"this changed my routine\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/videos/jobs/42/approve")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {hook_text: "this changed my routine"}.to_json
res = http.request(req)
puts res.body

POST /videos/jobs/{id}/regenerate

Re-roll the reaction (consumes one allowance). Optionally change the inputs.

Field	Type	Required	Description
`prompt`	string	no	New prompt (method=prompt).
`avatar_id`	int	no	New avatar (method=motion).
`video_source`	string	no	New source (method=motion): `link` or `upload`.
`reference_url`	string	no	New TikTok URL when `video_source=link`.

To swap in a new uploaded motion clip, send multipart/form-data with a reference_video file field (same as create).

curl -X POST "https://your-host/api/v1/videos/jobs/42/regenerate" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"calmer, more genuine reaction"}'

import requests

res = requests.post(
    "https://your-host/api/v1/videos/jobs/42/regenerate",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"prompt": "calmer, more genuine reaction"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/videos/jobs/42/regenerate", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"prompt":"calmer, more genuine reaction"}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/videos/jobs/42/regenerate");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['prompt' => 'calmer, more genuine reaction']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"prompt":"calmer, more genuine reaction"}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/videos/jobs/42/regenerate", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/videos/jobs/42/regenerate"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"prompt\":\"calmer, more genuine reaction\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/videos/jobs/42/regenerate")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {prompt: "calmer, more genuine reaction"}.to_json
res = http.request(req)
puts res.body

Hooks

Generate viral hook ideas for a product.

POST /hooks

Generate hook ideas. (Rate limited.)

Field	Type	Required	Description
`product_id`	int	yes	The product to brainstorm hooks for.

curl -X POST "https://your-host/api/v1/hooks" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"product_id":1}'

import requests

res = requests.post(
    "https://your-host/api/v1/hooks",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"product_id": 1},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/hooks", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"product_id":1}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/hooks");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['product_id' => 1]),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"product_id":1}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/hooks", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/hooks"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"product_id\":1}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/hooks")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {product_id: 1}.to_json
res = http.request(req)
puts res.body

Usage

Plan, monthly reaction allowance, and saved-reaction library usage.

GET /usage

Current plan and remaining allowance.

curl -X GET "https://your-host/api/v1/usage" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/usage",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/usage", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/usage");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/usage", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/usage"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/usage")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

Social (publishing)

Publish finished videos to your connected channels (bring-your-own Postiz / post-bridge account).

GET /social/connections

Connected providers and their channels.

curl -X GET "https://your-host/api/v1/social/connections" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/social/connections",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/connections", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/connections");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/social/connections", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/connections"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/social/connections")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /social/accounts/sync

Re-sync channels from a provider.

Field	Type	Required	Description
`provider`	string	yes	`postiz` or `postbridge`.

curl -X POST "https://your-host/api/v1/social/accounts/sync" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider":"postiz"}'

import requests

res = requests.post(
    "https://your-host/api/v1/social/accounts/sync",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"provider": "postiz"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/accounts/sync", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"provider":"postiz"}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/accounts/sync");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['provider' => 'postiz']),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"provider":"postiz"}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/social/accounts/sync", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/accounts/sync"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"provider\":\"postiz\"}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/social/accounts/sync")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {provider: "postiz"}.to_json
res = http.request(req)
puts res.body

GET /social/posts

List publish actions (paginated).

curl -X GET "https://your-host/api/v1/social/posts" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/social/posts",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/posts", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/posts");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/social/posts", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/posts"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/social/posts")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

GET /social/posts/{id}

One post plus per-channel results.

curl -X GET "https://your-host/api/v1/social/posts/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/social/posts/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/posts/1", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/posts/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/social/posts/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/posts/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/social/posts/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /social/posts

Publish or schedule a video.

Field	Type	Required	Description
`provider`	string	yes	`postiz` or `postbridge`.
`video_id`	int	yes	The finished video to publish.
`account_ids`	array	yes	Channel account ids (array or comma list).
`caption`	string	no	Post caption.
`schedule_at`	string	no	ISO-8601 UTC time to schedule for.
`draft`	bool	no	Deliver to the platform drafts (e.g. TikTok) instead of posting.

curl -X POST "https://your-host/api/v1/social/posts" \
  -H "Authorization: Bearer $EUGC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider":"postiz","video_id":123,"account_ids":["acc_1"],"caption":"new drop","draft":true}'

import requests

res = requests.post(
    "https://your-host/api/v1/social/posts",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
    json={"provider": "postiz", "video_id": 123, "account_ids": ["acc_1"], "caption": "new drop", "draft": True},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/posts", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({"provider":"postiz","video_id":123,"account_ids":["acc_1"],"caption":"new drop","draft":true}),
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/posts");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => json_encode(['provider' => 'postiz', 'video_id' => 123, 'account_ids' => ['acc_1'], 'caption' => 'new drop', 'draft' => true]),
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{"provider":"postiz","video_id":123,"account_ids":["acc_1"],"caption":"new drop","draft":true}`)
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/social/posts", body)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/posts"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"provider\":\"postiz\",\"video_id\":123,\"account_ids\":[\"acc_1\"],\"caption\":\"new drop\",\"draft\":true}"))
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "json"
require "uri"

uri = URI("https://your-host/api/v1/social/posts")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
req["Content-Type"] = "application/json"
req.body = {provider: "postiz", video_id: 123, account_ids: ["acc_1"], caption: "new drop", draft: true}.to_json
res = http.request(req)
puts res.body

DELETE /social/posts/{id}

Delete/cancel a post, removing it upstream where supported. Postiz deletes scheduled or published posts; post-bridge deletes scheduled/draft posts only.

curl -X DELETE "https://your-host/api/v1/social/posts/1" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.delete(
    "https://your-host/api/v1/social/posts/1",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/social/posts/1", {
  method: "DELETE",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/social/posts/1");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://your-host/api/v1/social/posts/1", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/social/posts/1"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/social/posts/1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

Analytics

Aggregated performance across connected providers.

GET /analytics?days=30

Cached analytics overview.

curl -X GET "https://your-host/api/v1/analytics?days=30" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.get(
    "https://your-host/api/v1/analytics?days=30",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/analytics?days=30", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/analytics?days=30");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "GET",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://your-host/api/v1/analytics?days=30", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/analytics?days=30"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .GET()
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/analytics?days=30")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body

POST /analytics/sync?days=30

Pull fresh analytics from connected providers.

curl -X POST "https://your-host/api/v1/analytics/sync?days=30" \
  -H "Authorization: Bearer $EUGC_KEY"

import requests

res = requests.post(
    "https://your-host/api/v1/analytics/sync?days=30",
    headers={"Authorization": f"Bearer {EUGC_KEY}"},
)
print(res.json())

const res = await fetch("https://your-host/api/v1/analytics/sync?days=30", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.EUGC_KEY}`,
  },
});
const data = await res.json();
console.log(data);

$ch = curl_init("https://your-host/api/v1/analytics/sync?days=30");
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer {$EUGC_KEY}"],
]);
$data = json_decode(curl_exec($ch), true);
var_dump($data);

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://your-host/api/v1/analytics/sync?days=30", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EUGC_KEY"))
	resp, _ := http.DefaultClient.Do(req)
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.*;

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://your-host/api/v1/analytics/sync?days=30"))
    .header("Authorization", "Bearer " + System.getenv("EUGC_KEY"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(res.body());

require "net/http"
require "uri"

uri = URI("https://your-host/api/v1/analytics/sync?days=30")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == "https"
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['EUGC_KEY']}"
res = http.request(req)
puts res.body