LiveOps SDK reference

-- DevNet LiveOps for Roblox. Put this ModuleScript in ServerScriptService.
local HttpService = game:GetService("HttpService")
local Players = game:GetService("Players")

local KEY = "dn_live_your_key_here"
local EVENTS_URL = "https://devnet.lol/api/liveops/v1/events"
local CONFIG_URL = "https://devnet.lol/api/liveops/v1/config"

local DevNet = { config = {}, experiments = {} }
local queue, joinedAt = {}, {}

function DevNet.track(player, name, value, props)
	table.insert(queue, {
		name = name,
		player = tostring(typeof(player) == "Instance" and player.UserId or player),
		value = value,
		props = props,
		time = os.time(),
	})
end

local function flush()
	if #queue == 0 then return end
	local batch = queue
	queue = {}
	local ok, err = pcall(function()
		HttpService:RequestAsync({
			Url = EVENTS_URL,
			Method = "POST",
			Headers = { ["Content-Type"] = "application/json", ["X-DevNet-Key"] = KEY },
			Body = HttpService:JSONEncode({ events = batch }),
		})
	end)
	if not ok then warn("[DevNet] send failed:", err) end
end

-- Remote config, with this player's A/B test variants applied
function DevNet.getConfig(player)
	local url = CONFIG_URL .. "?player=" .. tostring(player and player.UserId or "")
	local ok, res = pcall(function()
		return HttpService:RequestAsync({ Url = url, Method = "GET", Headers = { ["X-DevNet-Key"] = KEY } })
	end)
	if ok and res.Success then
		local data = HttpService:JSONDecode(res.Body)
		return data.config, data.experiments
	end
	return DevNet.config, {}
end

Players.PlayerAdded:Connect(function(player)
	joinedAt[player] = os.clock()
	DevNet.track(player, "session_start")
end)
Players.PlayerRemoving:Connect(function(player)
	DevNet.track(player, "session_end", math.floor(os.clock() - (joinedAt[player] or os.clock())))
	joinedAt[player] = nil
end)
game:BindToClose(flush)

task.spawn(function()
	DevNet.config = DevNet.getConfig(nil)
	while true do
		task.wait(15)
		flush()
	end
end)

return DevNet

-- Usage, from any server script:
-- local DevNet = require(game.ServerScriptService.DevNet)
-- DevNet.track(player, "purchase", 99, { item = "Speed Coil", currency = "robux" })

// DevNet LiveOps for Unity. Add this component to a GameObject in your first scene.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;

public class DevNet : MonoBehaviour
{
    const string Key = "dn_live_your_key_here";
    const string EventsUrl = "https://devnet.lol/api/liveops/v1/events";
    const string ConfigUrl = "https://devnet.lol/api/liveops/v1/config";

    public static DevNet Instance { get; private set; }
    public string PlayerId { get; private set; }
    public string ConfigJson { get; private set; } = "{}";

    readonly List<string> queue = new List<string>();
    float sessionStart;

    void Awake()
    {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
        PlayerId = PlayerPrefs.GetString("devnet_player", Guid.NewGuid().ToString("N"));
        PlayerPrefs.SetString("devnet_player", PlayerId);
        sessionStart = Time.realtimeSinceStartup;
        Track("session_start");
        StartCoroutine(FetchConfig());
        InvokeRepeating(nameof(Flush), 15f, 15f);
    }

    public void Track(string name, double? value = null, string propsJson = null)
    {
        var e = new StringBuilder("{");
        e.Append("\"name\":\"").Append(name).Append("\",\"player\":\"").Append(PlayerId).Append("\"");
        if (value.HasValue) e.Append(",\"value\":").Append(value.Value.ToString(System.Globalization.CultureInfo.InvariantCulture));
        if (!string.IsNullOrEmpty(propsJson)) e.Append(",\"props\":").Append(propsJson);
        e.Append(",\"time\":").Append(DateTimeOffset.UtcNow.ToUnixTimeSeconds()).Append("}");
        queue.Add(e.ToString());
    }

    void Flush()
    {
        if (queue.Count == 0) return;
        var body = "{\"events\":[" + string.Join(",", queue) + "]}";
        queue.Clear();
        StartCoroutine(Post(body));
    }

    IEnumerator Post(string body)
    {
        using var req = new UnityWebRequest(EventsUrl, "POST");
        req.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
        req.downloadHandler = new DownloadHandlerBuffer();
        req.SetRequestHeader("Content-Type", "application/json");
        req.SetRequestHeader("X-DevNet-Key", Key);
        yield return req.SendWebRequest();
    }

    IEnumerator FetchConfig()
    {
        using var req = UnityWebRequest.Get(ConfigUrl + "?player=" + PlayerId);
        req.SetRequestHeader("X-DevNet-Key", Key);
        yield return req.SendWebRequest();
        if (req.result == UnityWebRequest.Result.Success) ConfigJson = req.downloadHandler.text; // parse with JsonUtility or your JSON library
    }

    void OnApplicationQuit()
    {
        Track("session_end", Math.Round(Time.realtimeSinceStartup - sessionStart));
        Flush();
    }
}

// Usage: DevNet.Instance.Track("purchase", 4.99, "{\"item\":\"starter_pack\",\"currency\":\"usd\"}");

// DevNet LiveOps for Unreal Engine 5. A small helper you can call from C++ or wrap for Blueprints.
#pragma once
#include "CoreMinimal.h"
#include "HttpModule.h"
#include "Interfaces/IHttpRequest.h"
#include "Interfaces/IHttpResponse.h"

class FDevNet
{
public:
    static constexpr const TCHAR* Key = TEXT("dn_live_your_key_here");
    static constexpr const TCHAR* EventsUrl = TEXT("https://devnet.lol/api/liveops/v1/events");
    static constexpr const TCHAR* ConfigUrl = TEXT("https://devnet.lol/api/liveops/v1/config");

    // Sends one event. Batch on a timer if you send many per second.
    static void Track(const FString& Name, const FString& PlayerId, TOptional<double> Value = {}, const FString& PropsJson = TEXT(""))
    {
        FString Event = FString::Printf(TEXT("{\"name\":\"%s\",\"player\":\"%s\",\"time\":%lld"), *Name, *PlayerId, FDateTime::UtcNow().ToUnixTimestamp());
        if (Value.IsSet()) Event += FString::Printf(TEXT(",\"value\":%f"), Value.GetValue());
        if (!PropsJson.IsEmpty()) Event += TEXT(",\"props\":") + PropsJson;
        Event += TEXT("}");

        auto Request = FHttpModule::Get().CreateRequest();
        Request->SetURL(EventsUrl);
        Request->SetVerb(TEXT("POST"));
        Request->SetHeader(TEXT("Content-Type"), TEXT("application/json"));
        Request->SetHeader(TEXT("X-DevNet-Key"), Key);
        Request->SetContentAsString(TEXT("{\"events\":[") + Event + TEXT("]}"));
        Request->ProcessRequest();
    }

    // Fetches remote config with the player's A/B variants; OnDone gets the raw JSON.
    static void FetchConfig(const FString& PlayerId, TFunction<void(const FString&)> OnDone)
    {
        auto Request = FHttpModule::Get().CreateRequest();
        Request->SetURL(FString(ConfigUrl) + TEXT("?player=") + PlayerId);
        Request->SetHeader(TEXT("X-DevNet-Key"), Key);
        Request->OnProcessRequestComplete().BindLambda([OnDone](FHttpRequestPtr, FHttpResponsePtr Res, bool bOk)
        {
            if (bOk && Res.IsValid() && Res->GetResponseCode() == 200) OnDone(Res->GetContentAsString());
        });
        Request->ProcessRequest();
    }
};

// Usage: FDevNet::Track(TEXT("session_start"), PlayerState->GetUniqueId().ToString());

# DevNet LiveOps for Godot 4. Add as an Autoload named "DevNet".
extends Node

const KEY := "dn_live_your_key_here"
const EVENTS_URL := "https://devnet.lol/api/liveops/v1/events"
const CONFIG_URL := "https://devnet.lol/api/liveops/v1/config"

var player_id := ""
var config := {}
var experiments := {}
var _queue: Array = []
var _started := 0

func _ready() -> void:
	var f := ConfigFile.new()
	f.load("user://devnet.cfg")
	player_id = f.get_value("devnet", "player", "")
	if player_id == "":
		player_id = str(randi()) + str(Time.get_unix_time_from_system())
		f.set_value("devnet", "player", player_id)
		f.save("user://devnet.cfg")
	_started = Time.get_ticks_msec()
	track("session_start")
	fetch_config()
	var timer := Timer.new()
	timer.wait_time = 15.0
	timer.autostart = true
	timer.timeout.connect(flush)
	add_child(timer)

func track(name: String, value = null, props := {}) -> void:
	var e := { "name": name, "player": player_id, "time": int(Time.get_unix_time_from_system()) }
	if value != null: e["value"] = value
	if not props.is_empty(): e["props"] = props
	_queue.append(e)

func flush() -> void:
	if _queue.is_empty(): return
	var body := JSON.stringify({ "events": _queue })
	_queue = []
	var http := HTTPRequest.new()
	add_child(http)
	http.request_completed.connect(func(_r, _c, _h, _b): http.queue_free())
	http.request(EVENTS_URL, ["Content-Type: application/json", "X-DevNet-Key: " + KEY], HTTPClient.METHOD_POST, body)

func fetch_config() -> void:
	var http := HTTPRequest.new()
	add_child(http)
	http.request_completed.connect(func(_r, code, _h, body):
		if code == 200:
			var data = JSON.parse_string(body.get_string_from_utf8())
			config = data.get("config", {})
			experiments = data.get("experiments", {})
		http.queue_free())
	http.request(CONFIG_URL + "?player=" + player_id, ["X-DevNet-Key: " + KEY])

func _notification(what: int) -> void:
	if what == NOTIFICATION_WM_CLOSE_REQUEST:
		track("session_end", (Time.get_ticks_msec() - _started) / 1000)
		flush()

# Usage: DevNet.track("level_up", 5)

// DevNet LiveOps for Minecraft servers (Paper/Spigot). Call new DevNetTracker(this) in onEnable().
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;

public class DevNetTracker implements Listener {
    private static final String KEY = "dn_live_your_key_here";
    private static final String EVENTS_URL = "https://devnet.lol/api/liveops/v1/events";
    private final HttpClient http = HttpClient.newHttpClient();
    private final Queue<String> queue = new ConcurrentLinkedQueue<>();
    private final Map<UUID, Long> joined = new HashMap<>();

    public DevNetTracker(JavaPlugin plugin) {
        Bukkit.getPluginManager().registerEvents(this, plugin);
        // Send every 15 seconds, off the main thread
        Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, this::flush, 300L, 300L);
    }

    public void track(UUID player, String name, Double value) {
        String v = value == null ? "" : ",\"value\":" + value;
        queue.add("{\"name\":\"" + name + "\",\"player\":\"" + player + "\"" + v + ",\"time\":" + (System.currentTimeMillis() / 1000) + "}");
    }

    @EventHandler public void onJoin(PlayerJoinEvent e) {
        joined.put(e.getPlayer().getUniqueId(), System.currentTimeMillis());
        track(e.getPlayer().getUniqueId(), "session_start", null);
    }

    @EventHandler public void onQuit(PlayerQuitEvent e) {
        Long start = joined.remove(e.getPlayer().getUniqueId());
        track(e.getPlayer().getUniqueId(), "session_end", start == null ? null : (System.currentTimeMillis() - start) / 1000.0);
    }

    public void flush() {
        List<String> batch = new ArrayList<>();
        for (String s; batch.size() < 100 && (s = queue.poll()) != null; ) batch.add(s);
        if (batch.isEmpty()) return;
        HttpRequest req = HttpRequest.newBuilder(URI.create(EVENTS_URL))
            .header("Content-Type", "application/json").header("X-DevNet-Key", KEY)
            .POST(HttpRequest.BodyPublishers.ofString("{\"events\":[" + String.join(",", batch) + "]}")).build();
        http.sendAsync(req, HttpResponse.BodyHandlers.discarding());
    }
}

-- DevNet LiveOps for Garry's Mod. Save as lua/autorun/server/devnet.lua
local KEY = "dn_live_your_key_here"
local EVENTS_URL = "https://devnet.lol/api/liveops/v1/events"
local queue, joined = {}, {}

DevNet = {}

function DevNet.Track(ply, name, value, props)
    table.insert(queue, { name = name, player = IsValid(ply) and ply:SteamID64() or tostring(ply), value = value, props = props, time = os.time() })
end

local function flush()
    if #queue == 0 then return end
    local body = util.TableToJSON({ events = queue })
    queue = {}
    HTTP({ url = EVENTS_URL, method = "POST", type = "application/json", body = body, headers = { ["X-DevNet-Key"] = KEY } })
end

hook.Add("PlayerInitialSpawn", "DevNetJoin", function(ply)
    joined[ply] = CurTime()
    DevNet.Track(ply, "session_start")
end)
hook.Add("PlayerDisconnected", "DevNetLeave", function(ply)
    DevNet.Track(ply, "session_end", math.floor(CurTime() - (joined[ply] or CurTime())))
    joined[ply] = nil
end)
hook.Add("ShutDown", "DevNetFlush", flush)
timer.Create("DevNetFlush", 15, 0, flush)

// DevNet LiveOps for Discord bots (Node.js 18+, no dependencies).
const KEY = "dn_live_your_key_here";
const EVENTS_URL = "https://devnet.lol/api/liveops/v1/events";
const CONFIG_URL = "https://devnet.lol/api/liveops/v1/config";
let queue = [];

export function track(userId, name, value, props) {
  queue.push({ name, player: String(userId), value, props, time: Math.floor(Date.now() / 1000) });
}

export async function getConfig(userId) {
  const res = await fetch(`${CONFIG_URL}?player=${userId ?? ""}`, { headers: { "X-DevNet-Key": KEY } });
  return res.ok ? res.json() : { config: {}, experiments: {} };
}

setInterval(async () => {
  if (!queue.length) return;
  const events = queue.splice(0, 100);
  await fetch(EVENTS_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-DevNet-Key": KEY },
    body: JSON.stringify({ events }),
  }).catch(() => queue.unshift(...events));
}, 15_000);

// Usage, e.g. in your interaction handler:
// track(interaction.user.id, "command", null, { name: interaction.commandName });

# Send events (up to 100 per request; batch every 10–30 seconds)
curl -X POST https://devnet.lol/api/liveops/v1/events \
  -H "Content-Type: application/json" \
  -H "X-DevNet-Key: dn_live_your_key_here" \
  -d '{"events":[{"name":"session_start","player":"player-123"},{"name":"purchase","player":"player-123","value":4.99,"props":{"item":"starter_pack","currency":"usd"}}]}'

# Read remote config, with this player's A/B test variants applied
curl "https://devnet.lol/api/liveops/v1/config?player=player-123" -H "X-DevNet-Key: dn_live_your_key_here"

# Event fields: name (required), player (required), value, session, props (JSON object), time (unix seconds)
# Standard events: session_start, session_end (value = seconds), purchase (value = price), level_up (value = level)