Technical reference

MCP tools

The studio’s tools for Claude, with their parameters.

Every tool the studio gives Claude over MCP (149). Connecting it: Claude over MCP.

A parameter marked ? can be left out. File paths are relative to the project folder.

Studio and project

studio_status

Studio state: open project, server and database state, detected FiveM, running players.

report_problem

Reports a problem with the studio itself (not with the user’s project) to the Webexe Studio team: a private Discord thread with the user. The studio builds a package (versions, plan, recent Output, problems, project resources and adapters, state) and cleans it of licence keys, tokens, passwords, the Windows user name, IP addresses and player identifiers. First call with send=false and show the user what will be sent; call again with send=true only after the user agrees. description: what went wrong, in the user’s language.

  • description string
  • screenshot? boolean: attach a screenshot of the studio window
  • send? boolean

project_list_recent

Recently opened projects.

project_open

Opens the project in the given folder (must contain studio.json). The server must be stopped.

  • dir string

project_import

Makes a studio project from an existing FiveM server (folder with server.cfg and resources/). By default the server is copied to target (a folder that does not exist or is empty) and the original is never written; inPlace: true makes the folder itself the project. Returns the report: gamebuild, port, OneSync, the adapters of its resources and how many capabilities they give, resources server.cfg starts that have no adapter (adapter_new makes one), SQL files of its resources (import_sql runs one in the studio database), and notes on what the studio server does differently.

  • dir string
  • target? string
  • inPlace? boolean

import_changes

For a project that is a copy of an imported server: files that differ from the original as imported (added, changed, deleted). studio: true marks the files and edits of the studio itself (scene, adapters, studio.json, its server.cfg lines), normally not sent back. conflict: true means the original changed that file since the import too.

import_apply

Copies the given changed files (paths from import_changes) back into the original server folder. Files with a conflict are not written unless force: true; the result lists them. Ask the user before force.

  • paths string[]
  • force? boolean

import_sql

Runs one SQL file of the project (a database dump or a resource’s schema, path relative to the project) in the studio’s database. The server must run.

  • file string

project_create

Creates a new project in parentDir/name and opens it. framework: none (default), qbox, esx, ox (ox_core) or qbcore. The framework is permanent.

  • name string
  • parentDir string
  • gameBuild? number
  • framework? enum

Server, database and logs

db_import_dump

Loads a dump of another server’s database (.sql or .sql.gz from mysqldump, HeidiSQL, phpMyAdmin; any absolute path) into the project’s database: streamed through the mariadb client, CREATE DATABASE/USE lines and DEFINER clauses of the old server left out, a snapshot taken first. The server must run. Ask the user first: it replaces tables with the same names.

  • file string

server_start

Starts the local server (database and FXServer). Returns at once; check state with studio_status, logs with log_read.

server_stop

Stops the local server and the database.

server_console

Sends a command to the FXServer console (e.g. “status”, “restart name”).

  • command string

config_read

A resource’s settings from its config file (config.lua, config/.lua, configs/.lua, shared/config.lua): simple values (number, text, true/false, vec3) with the key path, e.g. money.moneyTypes.cash. Without resource: a list of resources with such files. changed: what was changed in the studio.

  • resource? string
  • file? string

config_set

Changes one value in a resource’s config file in place (the rest of the file unchanged) and restarts the resource when the server runs. The change is kept in studio.lock and is reapplied to the file after a resource update. Paths and types from config_read; vector as [x, y, z].

  • resource string
  • file string
  • path string
  • value union

server_exec_lua

Runs Lua code on the server (the studio bridge’s environment, with access to server natives and exports). Returns the values from return. For checking state, not for lasting changes: write lasting code in the project’s resources.

  • code string

log_read

Reads the studio’s Output. sinceId: only entries newer than the given #id. source: studio, mcp, server or client. problems: only errors and warnings.

  • sinceId? number
  • source? studio | mcp | server | client
  • problems? boolean
  • limit? number

problems_list

Script errors collected from server and client logs: file (relative to the project), line, message, how many times it occurred. Restarting a resource clears its entries, so after a fix an empty list means the error is gone. Entries with side “manifest” are fxmanifest.lua errors (missing files, dependencies, stream folder); the studio checks them after every file save.

db_tables

Tables in the project’s local database (MariaDB) with approximate row counts. The database runs while the server runs.

db_query

An SQL query to the project’s local database. Read-only by default (SELECT, SHOW, DESCRIBE). To change data or the schema, set write: true. Dropping the whole database is blocked. Returns up to 500 rows. On the Creator plan and up, before every query with write: true the studio takes a database snapshot (auto-…), so the change can be undone with db_restore.

  • sql string
  • write? boolean

db_snapshot

Snapshots of the project’s local database (.studio/snapshots, outside Git). No arguments: list. With name: saves the current state under that name. The studio takes auto-… snapshots itself before every db_query with write: true (the last 5 are kept).

  • name? string

db_restore

Restores the project’s database from a snapshot (name from db_snapshot). Drops all current tables, including those added after the snapshot. A resource holding data in memory (e.g. the framework) sees the change after a restart.

  • name string

db_migrate

Project database migrations: files db/migrations/_.sql, each runs once (the studio records it in the studio_migrations table) on server start or on request. Write schema changes (CREATE/ALTER TABLE) as a migration, not through db_query, so they reach production too. No arguments: a list with state. create: name of a new migration (returns the file path for file_write). run: true runs the pending ones (snapshot before them).

  • create? string
  • run? boolean

db_seed

Project test data: files db/seeds/*.sql, loaded on request (can be repeated; snapshot before loading). Without name: list of files.

  • name? string

test_run

Runs project tests on the server: tests/**/*.test.lua or the given file/folder. File format: test(‘name’, function(t) t.equal(a, b) t.ok(cond, ‘description’) t.wait(ms) t.skip(‘reason’) end) test(‘name’, { gracz = 2 }, function(t) … end) – needs that player in game, otherwise SKIPPED (the option is called gracz). In a project with a framework: t.player(n) (character: job, gang, money, items), t.hasJob(n, job, grade), t.hasItem(n, item, count), t.money(n, account), t.query(sql, params) (database rows, through the db.query adapter of the project). Returns PASS/FAIL/SKIPPED for each test, with file and line on FAIL.

  • path? string

security_scan

Security analysis of the project’s scripts (without resources from studio.lock and cfx-default): server network events that trust data from the client (code/commands from arguments, amounts and items from arguments, actions on players without a permission check, missing source). Heuristic: verify each finding in the code.

Files and resources

resource_restart

Refreshes the resource list and starts or restarts the resource with the given name (refresh + ensure).

  • name string

resource_restart_group

Restarts all resources from a project folder one by one, e.g. the folder “resources/[my]”. Clients stay connected. Returns the list of names.

  • folder string

resource_create

Creates a new resource in resources/[my]/ from a template, adds ‘ensure ’ to server.cfg and starts it if the server runs. kind: lua (client.lua and server.lua, default), server, client, nui (in-game HTML page with an open command and Esc), ts (src/*.ts built to dist/). imports: ids from resource_templates (what the resources of the project offer); the studio adds their lines to fxmanifest.lua and the dependency. Then fill in the files with file_write.

  • name string
  • kind? lua | server | client | nui | ts
  • imports? string[]

resource_templates

Kinds of new resource and fxmanifest.lua imports provided by the project’s resources (a library’s shared_script line and the like). Exports of other resources work without an import.

resource_list

Resources on the running server with state (started, stopped, missing…), path and version.

resource_install

Installs a resource from GitHub (repo: owner/name) or from any git (repo: an https://, git@ or file:// address for a folder with a repository, version: branch or tag) into resources/ (default [deps]): the latest release or the given version (tag or commit), recorded in studio.lock with a SHA256 sum, ensure in server.cfg after its dependencies, start on the running server. A resource written for a different framework than the project is rejected (with a reason). Returns missing dependencies from fxmanifest. file: path to a .zip file on disk (e.g. a paid resource from portal.cfx.re with escrow) instead of repo; goes to [paid]. Without repo and file: a list of resources from studio.lock with versions.

  • repo? string
  • version? string
  • group? string
  • file? string

resource_update

Updates of resources from studio.lock. Without name: a list of newer releases on GitHub. With name: swaps in the newer version (or the given version), the previous one goes to .studio/backups. With rollback: true restores the version from before the last update.

  • name? string
  • version? string
  • rollback? boolean

file_list

List of project files and folders (folders end with /).

  • path? string
  • depth? number

file_read

Reads a project file (relative path).

  • path string

file_write

Writes a whole project file (creates folders on the way). Relative path.

  • path string
  • content string

file_rename

Renames or moves a file or folder in the project (relative paths).

  • from string
  • to string

file_delete

Moves a project file or folder to the Windows Recycle Bin (can be restored).

  • path string

Searches text in project files (case-insensitive unless matchCase). glob e.g. “*.lua”.

  • query string
  • glob? string
  • matchCase? boolean

file_replace

Replaces text (literally, not regex) in all of the project’s text files or only in the given files. The save works like file_write: while the server runs, resources with these files restart. Returns the number of files and replacements.

  • query string
  • replacement string
  • matchCase? boolean
  • files? string[]

Game and players

player_position

Where a studio player stands: pos [x, y, z], heading, interior (0 outside) and routing bucket.

  • player? number

player_teleport

Moves a studio player: to pos [x, y, z] (or [x, y]: onto the ground there), to a saved place, or in front of a scene object (object: id), turned to face it.

  • player? number
  • pos? union
  • place? string
  • object? string
  • heading? number

places_list

Saved project places (scenes/places.json): name, pos [x,y,z], heading. For scene_add at a known place or places_go.

places_go

Moves the player’s editor camera (or their character when not editing) to a saved place (name) or to coordinates (pos).

  • player number
  • name? string
  • pos?

world_set

Sets the time and weather for all players (e.g. to check scene lighting at night). frozen: the clock stands still. weather: EXTRASUNNY, CLEAR, CLOUDS, OVERCAST, SMOG, FOGGY, RAIN, THUNDER, CLEARING, SNOW, BLIZZARD, SNOWLIGHT, XMAS, HALLOWEEN.

  • hour? number
  • minute? number
  • weather? string
  • frozen? boolean

player_action

Makes a player nobody is controlling right now (usually Player 2) do something: come (runs to the other player), teleport (stands 1.5 m in front of the other player), vehicle (gets into the nearest car within 30 m), anim with arg: handsup, kneel, phone, smoke, sit, pushups, clipboard, stop (interrupts), bucket with arg: routing bucket number (0 is the shared world). Returns what happened.

  • player number
  • action come | teleport | vehicle | anim | stop | bucket
  • arg? union

inspect_entity

One entity as the server and every studio client see it: whether it exists, who owns it, position and difference from the server (offset in m), model, bucket. target: scene object id or network id. Helps with “Player 2 does not have it” or “it stands somewhere else for everyone”.

  • target string

inspect_state

A state bag key by key: the value on the server and on every client, differs = different somewhere or missing (e.g. set without replication). target: global, player 1, player 2, scene object id or entity network id.

  • target string

inspect_state_set

Sets a state bag key on the server with replication to everyone (same as editing in the Inspector). value: JSON (text in quotes), null removes the key. studio* keys are set by the studio and cannot be changed here. Returns the state bag after the change, with what the players see. target as in inspect_state.

  • target string
  • key string
  • value string

inspect_events

Watches events with the given names on the server and on clients: each event gives a log line “[event] name from whom: arguments”. names replaces the list (an empty list stops watching). Returns the list and the latest caught lines (server and clients).

  • names? string[]

scenario_list

Project Play scenarios (scenarios/.json). File: { “players”: { “1”: {…}, “2”: {…} }, “world”: { “hour”, “minute”, “weather”, “frozen” }, “control”: 1 }. Player: place (name of a saved place) or pos [x,y,z] + heading or near { “player”: 1, “distance”: 3 } (in front of that player, facing them), model (e.g. s_m_y_cop_01), weapons (e.g. [“WEAPON_PISTOL”], [] takes weapons away), bucket, role (admin/user). In a project with a framework also: job { name, grade }, gang { name, grade }, money { account: amount } (e.g. { “cash”: 500, “bank”: 0 }), items [{ name, count }] (the whole inventory). Job, gang, account and item names come from fw_catalog. Every field is optional. Save a new scenario with file_write or scenario_save.

scenario_run

Runs a scenario: sets the time, weather, players (position, model, weapons, bucket, role) and who controls. A player not in the game is started by the studio and set up after joining. Returns a list of what it did.

  • name string

scenario_save

Saves the current state (positions and models of players in game, buckets, roles, time, weather, who controls) as a scenario with this name. Overwrites an existing one.

  • name string

player_role

A player’s permissions on the local server: admin (player in group.admin, i.e. what the project’s server.cfg gives admins) or user (a normal player). At start both are admins, because FXServer gives group.admin to the key owner and both players play on the same account. The role goes to the principal player.. The studio grants it again when the player joins the game. Without the role argument: returns the current roles.

  • player? number
  • role? admin | user

player_toggles

Character toggles of Player 1 or 2: noclip (fly through walls), godmode (invincibility), invisible (invisible to others), timeScale (game speed for this player only: 1 normal, 0.25 four times slower; for watching animations and physics).

  • player number
  • noclip? boolean
  • godmode? boolean
  • invisible? boolean
  • timeScale? number

player_list

Players connected to the local server: id, name, ping, bucket.

client_exec_lua

Runs Lua code in the game client of the chosen player (1 or 2): client natives, PlayerPedId(), position, animations. Returns the values from return. Requires that player to be in the game (player_list shows studioPlayer).

  • player number
  • code string

game_screenshot

A screenshot of what a player sees in game: all players or one (player). Works also for a player whose window is covered. Before anyone joins the game, returns a screenshot of the game window (e.g. the loading screen). Returns images so you can see the effect in game.

  • player? number

game_launch

Starts the FiveM client and connects it to the local server. player 1 or 2 (the second client on the same computer).

  • player number

game_stop

Closes the FiveM client of Player 1 or 2 started by the studio (the whole process, not just a disconnect).

  • player number

Scene

scene_list

Project scene objects (props, peds, vehicles placed in the editor): id, type, model, pos [x,y,z], rot [pitch,roll,yaw] in degrees.

scene_server_list

What the server’s own resources put in the world (not the studio scene), as Gracz 1’s game saw it: peds, objects and vehicles made by scripts, with the resource that made them (from the game, or from the file the position is written in; null when neither says). The list grows while Gracz 1 moves around the map and remembers what it saw. match: the file and line the position is written in; only those can be moved (scene_server_move). refresh: look around Gracz 1 now. Filter by resource.

  • resource? string
  • refresh? boolean

scene_server_move

Moves an entity from scene_server_list that has a match (its position written in a resource file): that one value in the file is rewritten in its own form, kept in studio.lock, and the resource restarts. heading only when the line has one. Entities without a match cannot be moved.

  • key string
  • pos tuple
  • heading? number

scene_add

Places an object in the project scene. While the server runs it appears in game at once for all players; it is saved in scene.json of the studio_scene resource (works without the studio too). type: prop, ped or vehicle. Where to put it: pos (player_position gives where a player stands), or placement relative to scene objects, from which the studio computes positions and angles from the sizes of the models: on “ground” (the height of the ground under it; the default with the relations below) or { surface: id } (on top of that object), facing: an object id or a point, beside: { of, side: front|back|left|right, gap }, around: { of, count, gap } (count copies around it, each facing it), along: { from, to, count }. Props are frozen unless frozen: false. The result has the anomalies of what was placed (objects in each other, a seat with its back to its table, floating or sunk, in a wall of the map) with fixes: finish only when scene_check reports none, then look with game_screenshot. Round zone: zone.radius; polygon: zone.points [[x, y], …] (min. 3) with minZ and maxZ. Blip: blip.radius draws an area on the map, blip.job shows it only to that job.

  • type prop | ped | vehicle | blip | marker | zone | door
  • model? string
  • pos?
  • placement? union
  • npc? object
  • blip? object
  • marker?
  • zone? object
  • door? object: second leaf of a double door
  • rot?
  • frozen? boolean
  • vehicleType? string
  • name? string
  • group? string

scene_update

Changes a scene object: position, rotation, model, frozen, name, group (folder in the tree, e.g. police_station), locked (the in-game editor does not pick it), disabled (stays in scene.json, not placed in game), alpha (0 invisible … 255 full), collision (false: players and cars pass through it). Give the id and only the fields to change; the change applies in game at once.

  • id string
  • model? string
  • pos?
  • rot?
  • frozen? boolean
  • name? string
  • group? string
  • locked? boolean
  • disabled? boolean
  • alpha? number
  • collision? boolean
  • npc? object
  • blip? object
  • marker?
  • zone? object
  • door? object: second leaf of a double door

scene_check

Anomalies of scene objects (all, the given ids, or one group): objects in each other, a seat facing away from its table, too far from it or at the wrong height, an umbrella through a table without a hole, duplicates, furniture that is not frozen; with Gracz 1 in the game also floating or sunk into the ground, inside the map, a flat prop flickering. Each has a fix where one exists; fix: true applies them all. unmeasured: models not measured yet (they are measured in the game of Gracz 1). A seat without a known front: set it with model_front.

  • ids? string[]
  • group? string
  • fix? boolean

model_front

What the studio knows about a model and what you tell it: front (degrees, like a heading in the frame of the model: 0 its +Y, 90 its -X, 180 its -Y; null forgets it), kind (seat, table, umbrella, counter, flat, other), hole (a table with a hole for an umbrella). Kept in the project (scenes/models.json); used by placement and scene_check. Seats have their front and sitting height measured in the game from the backrest; set it by hand when that is wrong or for anything else that has a front. Without any field: what is known.

  • model string
  • front? number
  • kind? seat | table | umbrella | counter | flat | other
  • hole? boolean

scene_prefab

Scene prefabs (scenes/prefabs/.json): a group of objects saved once and inserted many times. No arguments: list. save: name of a scene group (saves it as a prefab, optionally under name). insert: prefab name, inserts it as a new group at pos with heading, or 4 m in front of the player (player), rotated like them.

  • save? string
  • name? string
  • insert? string
  • pos?
  • heading? number
  • player? number

scene_remove

Removes an object from the scene (from the game and from scene.json).

  • id string

scene_ipl

Turns an IPL on (on) or off (off) in the project scene: parts of the map and interiors, e.g. removing a building or adding an interior; default takes it off the list. Saved in scene.json, works live for all players and without the studio. Without name: returns the current lists.

  • name? string
  • state? on | off | default

scene_map_object

The GTA map object (not from the scene) the user last clicked in the in-game editor (F5): model, hash, location, rotation. When the user says “this object”, “what I clicked”: a mechanic on it is mech_save with target { kind: “mapObject”, model, coords }.

Mechanics

mech_catalog

What a mechanic is made of (an interaction on an object or a rule for the whole world): targets (target), triggers (trigger), conditions (conditions) and steps (steps), each with fields. available: false means the project has no resource that performs it (see caps_list). Mechanics work without the studio, also in production, and the server checks distance and conditions. Use mechanics for interactions (shop, stash, pick up and carry, duty); write logic beyond the steps in a normal resource and call it with an event or export step.

mech_list

Project mechanics (studio_scene/mechanics.json).

mech_save

Adds or changes (by id) a mechanic and turns it on in game at once, without a restart. Fields: name, target { kind, … }, trigger { kind, … }, conditions [{ kind, … }], steps [{ kind, … }], distance (m), cooldown (ms), enabled. Example of picking up a tyre from the map: target { kind: “model”, models: [“prop_wheel_tyre”] }, trigger { kind: “target”, label: “Pick up tyre” }, conditions [{ kind: “noState”, key: “studioCarry” }], steps [{ kind: “carry” }, { kind: “hideWorld”, respawn: 600 }]. Trigger “target” works only where mech_catalog aim[target kind] is true (a targeting resource with an adapter); otherwise use “nearby” or propose an adapter. One specific GTA map object (the one the user clicked in the editor, scene_map_object): target { kind: “mapObject”, model, coords: [x, y, z] }.

  • mechanic record

mech_remove

Removes a mechanic by id.

  • id string

mech_trace

Latest mechanic uses on the server: player, mechanic, result (ok, rejected, condition, interrupted) and reason, e.g. which condition failed or which step did not succeed.

mech_try

Tries a saved mechanic on a studio player: the player stands at the target (scene object, map object, place; for a model or entity type the nearest within 60 m) and uses it with the same event as in game, with the same server checks. Returns the result from the trace (ok, rejected, condition, interrupted) and the reason.

  • id string
  • player? number

Capabilities, adapters and framework

fw_player

The character of Player 1 or 2, through the project’s adapters (any framework with a player.get adapter): name, job and grade, gang, money in accounts, inventory. loggedIn: false means the player is still at character selection. With the change field it changes the character through the adapters (player.setJob, player.setMoney, inventory.add…; a missing one is named in the error): job { name, grade }, gang { name, grade }, money { account: amount }, items [{ name, count }] (replaces the whole inventory), give { name, count }, take { name, count }. Take names from fw_catalog.

  • player number
  • change? object

fw_catalog

Jobs (with grades), gangs, items and money accounts the project’s resources give (catalog.* capabilities of their adapters). Optional filter by item, job or gang name.

  • filter? string

caps_list

Project capabilities: general operations such as inventory.add, shop.register, ui.progress, target.addModel, and the adapter (resource) that performs them. Mechanics and the studio use only capabilities, never framework names; no adapter means the project does not have that capability. Each has fields (args) and a side (server or client).

  • group? string

adapter_new

Adapter skeleton for a resource the studio does not know (a community framework, your own): adapters// in the project with adapter.json, server.lua and client.lua. The files contain all capabilities as comments and the exports found in the resource’s code. Fill them in with file_write, list the capabilities in adapter.json (server, client), call adapters_sync, then caps_check. from: an existing adapter to start from instead (a fork of a known resource under another name): its files are copied with the names changed. Saving a file under adapters/ reloads the adapter and checks its capabilities by itself while the server runs.

  • resource string
  • from? string: id of an adapter to copy, e.g. the one of the resource this one is a fork of

adapter_customize

Copies one of the studio’s adapters into the project as its own (adapters/, the same id, so it wins), to change it for this server. Later versions from the studio go to .studio/backups/adapters to compare. Returns the files.

  • id string

adapters_sync

Copies the adapters (the studio’s and the project’s from adapters/) into the project’s runtime and restarts studio_scene so it loads the changes. Use after editing your own adapter.

adapters_rollback

Goes back to the adapter the project had before the studio brought a newer one (caps_list shows previous). The old version becomes the project’s own adapter in adapters/; deleting that folder restores the studio’s version.

  • id string

caps_choose

When several adapters provide the same capability (e.g. two inventories), chooses which one performs it. adapter: null goes back to the adapter order. The choice is saved in the project (studio_scene/providers.json), so the production server chooses the same; a running server picks it up at once.

  • cap string
  • adapter string

caps_check

Capability conformance tests on the running server with Player 1 (with a character): each capability used as a mechanic would and the state restored (job, money, item). ok, fail with a reason, or none (no adapter performs it). An adapter, including one you wrote, is ready when its capabilities are ok. adapter: check only the capabilities of that adapter.

  • adapter? string

fw_test_characters

Ready test character: every studio player gets the character “Gracz N” instead of the character selection screen and spawn picker (created once, then loaded). Needs adapters with character.selectOpen (game), character.list, character.login and character.create or character.prepare; caps_list shows which the project has. on: true/false saves the setting in studio.json. Without on: loads the given player’s test character now (player).

  • on? boolean
  • player? number

fw_characters

Characters of the studio player’s account (character.list of the project’s adapters; both players play on one account, so they see the same ones). Without login: a list (id, first and last name, job). login: logs the player into that character, like choosing it on the character screen; the player must be at character selection. Characters are created normally in game; the studio only logs into them (character.login).

  • player? number
  • login? string

fw_check

Checks the project’s own Lua code (without resources from studio.lock): calls to a framework other than the project’s, e.g. ESX.GetPlayerFromId in a Qbox project. The studio rejects a file_write save with such a call, giving the line number.

Items, attachments and animations

anim_bones

Freemode character skeleton for animation (measured in game): bone names, their ids (tag) and parents, plus IK ends (hands, feet, head) with the bone chain each one moves. Ped space: X right, Y forward, Z up, metres, origin at SKEL_ROOT (about 1 m above the ground).

anim_list

Project animations (animations/.json), the same as in the Animations tab.

anim_get

An animation: dictionary, clip, duration, loop and the keys of every bone (time in s, local rotation as quaternion x,y,z,w).

  • dict string

anim_set_keys

Creates or changes an animation (saved in animations/.json, shown at once in the Animations tab). keys: bone (name from anim_bones, e.g. SKEL_R_Forearm or R_Forearm, or tag), time t in seconds and rotation [x, y, z] in degrees around the bone’s own axes, added to the standing pose ([0,0,0] = standing). Forearm and fingers bend mainly around Z. Motion between keys is smooth; a bone without keys stays as in the standing pose. clear: true starts from empty. Then anim_export to see it in game.

  • dict string
  • clip? string
  • duration? number
  • loop? boolean
  • clear? boolean
  • keys? array

anim_ik

Moves a hand, foot or the head by move [dx, dy, dz] metres (X right, Y forward, Z up) at time t, like dragging in the editor: the arm or leg bends by itself (IK), and the chain bones get keys. fullBody: moves the torso too. Returns where the end got to and how far it fell short.

  • dict string
  • t number
  • end union
  • move tuple
  • fullBody? boolean

anim_export

Saves the animation as .ycd in resources/[my]/studio_anims/stream/ (the game plays it with TaskPlayAnim(ped, dict, clip, …)). With player: that player reconnects so the game loads the new file (up to about 2 min), and plays the animation; check the effect with game_screenshot.

  • dict string
  • player? number

anim_from_video

Makes an animation from a recording of a person: a video file on disk (path, mp4/webm/mov); the studio detects the pose in every frame (MediaPipe Pose, locally) and transfers it to the skeleton: hips, spine, head, arms, legs, hands, feet. Saved in animations/.json (shown in the Animations tab), a key every frame. start/end: segment in seconds, fps: frames per second (default 30), quality: heavy (default, more accurate) or full (faster). Feet stay on the ground (the whole character lowers in a squat). Best: the whole body in frame, one person, static camera. Video gives no fingers and no movement of the whole character; fix those with anim_set_keys, then anim_export.

  • path string
  • dict string
  • clip string
  • fps? number
  • quality? heavy | full
  • start? number
  • end? number

anim_stop

Stops the animation the player’s character is playing (after anim_export with player or TaskPlayAnim) so it can walk again.

  • player number

Searches model names for scene_add: type prop (studio catalog, about 21k props), ped or vehicle (vehicles from the player’s game, also those added on the server). Returns the hit count and up to 40 names, those starting with the query first (e.g. “barrier”, “chair”, “police”).

  • type prop | ped | vehicle
  • query string

item_define

A new project item or a change to an existing entry: item, weapon, ammo or weapon component (an entry from the resource’s file goes into the studio block and survives a resource update). The inventory resource saves it through its adapter, then the studio restarts it. Current values, the whole definition (def) and the entry code (code) come from item_info. Three ways: 1) simple fields change only themselves, the rest of the definition stays; 2) config: the whole definition as in def from item_info (vectors as { x, y, z }, hashes as NAME), replaces the entry; 3) code: the entry’s Lua code, e.g. “[‘name’] = { label = ‘…’, weight = 100, client = { … } }”, functions included; the studio checks that the file loads. Fields: name (new: lowercase letters, digits, _), label, weight (g), description, stack, image, usable (using it from the inventory runs mechanics with target item and trigger use), config, code, imageFile (path to a .png, .jpg or .webp on this computer: the studio saves it as .png where the inventory resource keeps item images). To change only the image, without changing the item, use item_image.

  • item? object

attach_list

Project attachments (studio_scene/attachments.json): a prop on a ped bone with offset pos (m) and rotation rot (°) in bone space, plus a holding animation. Used by the mechanic step carry (attachment field), scene NPCs (npc.prop) and code: exports.studio_scene:attachProp(ped, name) on the client. With bones=true: a list of common bones with their numbers.

  • bones? boolean

attach_save

Saves an attachment (new or a change; renamed: the previous name). A running server picks it up at once. Also returns ready code: plain natives, the studio_scene export, and a version for each resource of the project whose adapter has one.

  • attachment
  • renamed? string

attach_remove

Removes an attachment from the project.

  • name string

attach_show

Shows an attachment in a studio player’s game (prop on the bone and animation) so you can check it with game_screenshot. stop=true takes it off. npc: id of a scene NPC instead of a player. For manual placement with a gizmo there is the “Set up in game” button (Polish UI: “Ustaw w grze”) in the Attachments tool.

  • attachment?
  • name? string
  • player? number
  • npc? string
  • stop? boolean

item_info

Entry data (item, weapon, ammo, component) for editing: label, weight, description, stack, image, usable, kind, def (the whole definition in use), code (the entry’s Lua code: from the studio block, otherwise from the resource’s file), hasCode (the definition has functions: change it through code), studio (the entry is in the studio block), fromFile (the entry comes from the resource’s file).

  • name string

item_image

A new image for an item (weapons too) without changing its definition: file is a .png, .jpg or .webp on this computer; the studio saves it as .png where the inventory resource keeps images (scales down above 512 px), and restarts the resource.

  • name string
  • file string

item_remove

Removes an item through the inventory resource’s adapter (one added by the studio disappears from the block, an item from the resource’s file gets an entry = nil in the studio block). The resource is restarted. Players who have it keep an item the resource does not know.

  • name string

Clothing and tattoos

clothing_bases

Base models of clothing and accessories in the project (clothing/bases): id, name, character, kind. Custom clothing is made on them (clothing_create, the designer). Kinds: . Without a model of a given kind, take one from the game files: clothing_game_list, then clothing_import_game. A model from outside the game (an addon pack) the user provides as .ydd and .ytd files: clothing_import_base.

clothing_game_list

Clothing models from the user’s game files (base game and DLC packs), to pick a base for clothing_import_game. ped: mp_m_freemode_01 or mp_f_freemode_01. component: . pack: DLC pack name (e.g. mpluxe), “” = base game. Returns key, the model number in its collection, the pack and the texture count. The first call reads the game archives (a few seconds). Empty placeholders from the game (fewer than 12 triangles) are rejected only by the import.

  • ped mp_m_freemode_01 | mp_f_freemode_01
  • component string
  • pack? string
  • limit? number

clothing_import_game

A base model from the game files (key from clothing_game_list): the studio extracts the model and texture from the user’s GTA V archives and saves the base in the project. Returns the base id for clothing_create and clothing_design.

  • key string
  • name? string

clothing_import_base

Imports a base model from the user’s files (a model from outside the game, e.g. an addon pack; take a game model with clothing_import_game): ydd (model, e.g. jbib_000_u.ydd or p_head_000.ydd) and ytd (texture, e.g. jbib_diff_000_a_uni.ytd; without ytd it looks for one next to the model). ped and component are detected from the file name when you do not give them. component: . Returns the base id for clothing_create.

  • ydd string
  • ytd? string
  • ped? mp_m_freemode_01 | mp_f_freemode_01
  • component? string
  • name? string

clothing_create

Quick path: clothing from ONE image. For designs with part colours, text, shapes and several images use clothing_design (they can be fixed later in the designer). Custom clothing or an accessory (addon, does not replace game items) from an image: takes a base model from the project (clothing_bases), applies the image as a print (keeping the fabric folds and shadows) and builds the studio_clothing resource (added to server.cfg, streamed to all players). image: path to a PNG/JPG on disk (e.g. an image pasted by the user). id: lowercase letters, digits, _. base: base model id (required for a new id). area: front (default) or back; rect [u, v, width, height] in 0..1 of the texture instead of area (e.g. [0,0,1,1] = the whole texture, colour of the whole item); size 0.1..1 relative to the area; offset [x, y] in fractions of the area (negative y = higher). cutout: true removes a light background (e.g. a photo of a white T-shirt with a print: only the print stays). crop: [x, y, width, height] in image pixels, before cutout. The same id again: replaces the print; addPrint: true adds another one (e.g. on the back). New clothing takes a free slot of that base model the game already knows, so you can put it on at once with clothing_wear (no rejoin); when free slots run out, clothing_wear reconnects the player by itself. Changing an existing one: the texture is swapped in game live.

  • id string
  • image string
  • base? string
  • area? string
  • rect? number[]
  • size? number
  • offset? number[]
  • rotate? number
  • cutout? boolean
  • crop? number[]
  • addPrint? boolean

clothing_parts

Parts of a base model for designing in clothing_design: an image of the plate (texture) with numbered pieces in colours, and part names with piece numbers (front, back, sides, top, bottom, torso, sleeves, left_sleeve, right_sleeve, left, right, all; left/right = the character’s side). Look at the image before choosing parts or numbers. cmPerPlate: how many cm on the character the full plate width is (null: unknown). Accessories (watches, bracelets, glasses, hats) lie in bone space, so their parts may be named differently than on the character (a watch face is usually bottom): check in the 3D preview (top and bottom views, clothing_view angles) and turn the layer with rotate.

  • base string

clothing_design

Designs custom clothing in layers with the same engine as the studio designer (it can then be opened and fixed in the Clothing tab), saves it and builds the studio_clothing resource. Returns two images: the texture (plate with the cut pattern) and the 3D model from four sides (front, back, sides of the character). Look at both and fix the design before you consider it done; the game is needed only for the final check on the character. id: lowercase letters, digits, _. base: model from clothing_bases (required for a new one). name: name for people. fabric: colour of the whole fabric #rrggbb (null: the original from the game). shading 0..1: strength of the game fabric folds and shadows (default 0.8). shadingMode: “folds” (default in new designs: only the model folds, without stripes, text and stains from the base texture) or “base” (shadows together with the base pattern). layers, bottom to top (part colours always go under text and images): {type:“fill”, color, part, pattern?} part colour (e.g. part:“sleeves”, [“front”,“back”], piece numbers from clothing_parts, “sleeves&left” = intersection; except: exclusions); pattern: {type: stripes|checker|dots|gradient|camo|acidwash|distressed, color2, color3?, size? (plate px, default about 43), angle? (degrees), amount?, seed?}: a pattern instead of a solid colour (color = the first colour). Patterns follow the position on the character: stripes angle 90 = horizontal, even all around; angle 0 = vertical (along the arm on sleeves); gradient from top to bottom of the garment; camo without seams. acidwash: bleached denim, marbled without seams, with twill and yarn streaks (color = dark indigo, color2 = bleached, color3 = thin veins on the stain edges; size = stain scale). distressed: horizontal rips in rows like frayed jeans, white weft threads across each hole, ragged edges, threads hanging down and frayed hems (color = threads, color2 = shadow in the hole, color3 = frayed fibres; amount 0..1 = how many, default 0.6; seed = another layout); transparent outside the rips, so put it as a separate layer above the fabric (e.g. acidwash on part “all”, distressed on the same part above it). {type:“text”, text ( = new line), color, font (Impact, Arial Black, Arial, Segoe UI, Verdana, Trebuchet MS, Georgia, Times New Roman, Courier New, Comic Sans MS), bold, italic, outline:“#rrggbb”, shadow: “#rrggbb” or {color, x, y, blur} (fractions of the letter height), arc: arc in degrees (positive = arching up like a rainbow, negative down)}; {type:“image”, image: PNG/JPG path on disk, removeBackground: true removes a solid background}; {type:“svg”, svg: SVG code or path to an .svg file}: custom vector graphics (logo, crest, emblem, illustration, decorative lettering), drawn sharp at the layer size; needs a viewBox; everything a browser draws works (paths, gradients, filters, text with a system font), without images and fonts from the web. Colour variants change it only through hue. {type:“shape”, shape: rect|ellipse|triangle|star|heart|line, fill, stroke (colours or null), strokeWidth (plate px, about 1024 px wide), radius, pattern (as above, inside the shape)}. Position of text, images and shapes: part (default “front”), x and y = centre in fractions of that part (0..1; y = 0 is the top of the part on the character; default 0.5 and 0.4), size: width / height as a fraction of the part or widthCm / heightCm on the character; rotate (degrees), flipX. The studio rotates them itself so they are straight and not mirrored on the character. clip: true clips the layer to its part (e.g. a band at the cuff wider than the sleeve does not spill onto other plate pieces). Every layer: id (for a later change or removal), name, opacity 0..1, blend (source-over, multiply, screen, overlay, darken, lighten, color, difference). mode: “replace” (default when you give layers: replaces all layers) or “add” (appends; a layer with an existing id replaces it). remove: ids of layers to remove. Layers from clothing_view (with the kind field, position in pixels) can be sent back changed. build: false = preview only, no save; the studio remembers that preview, so the next call with the same id (mode “add”, remove, build: true) fixes it without sending everything again. variants: colour variants of the same design (in game, further textures of this garment, selectable in the shop): [{name, colors: {“#colour from the design”: “#new”}, hue?: hue rotation of images}]; the whole list replaces the previous one, [] removes them. It then returns a third image: the front in every variant. from: id of another design + base: copies it onto another model (e.g. the same design on a women’s T-shirt); layers you added are laid out again relative to the new model’s parts, the rest goes to the same place on the plate (notes says which). Changing base of an existing design works the same way. Hot reload: the collection has a few free slots per base model (3 colour variants each) that the game knows from joining; new clothing takes such a slot and can be put on at once with clothing_wear, and the texture reaches the game live. Only when the game does not know the slot (free ones used up in this session, model imported after joining) or the variant does clothing_wear reconnect the player by itself. Changing clothing the game already has (also with build: false): the studio swaps the texture in game live, without rejoining; saved.note says for whom.

  • id string
  • base? string
  • name? string
  • fabric? string
  • shading? number
  • shadingMode? folds | base
  • mode? replace | add
  • layers? object[]
  • remove? string[]
  • build? boolean
  • variants? object[]
  • from? string

clothing_photo_job

Clothing from photos (step 1 of making a garment 1:1 from reference photos): a job in the project with the photos of ONE garment (front, side, back; up to 8), analysed in the studio window: MediaPipe body points (hips, knees, ankles, shoulders…), a mask of the garment of the given kind (clothes pixels in the body region of that kind), which side the photo shows (front, back, left = the person’s left side, right) and notes (e.g. a hand in a pocket inside the garment outline). Returns the job and one overlay image per photo (garment tinted, skeleton drawn): CHECK them; a wrong mask or side makes every later step wrong (fix by better photos, remove: [numbers]). id: lowercase letters, digits, _. kind (required for a new job): lowr trousers, jbib top/jacket, feet shoes, p_head hat… images: paths to PNG/JPG/WEBP (e.g. images the user pasted); added to the job, replace: true replaces them. A sheet of views from an image generator (2x2, 1x4, 3x1…) is split into one photo per view by itself (by the plain background between them); a photo stays whole; split: false keeps every image whole. warnings: views lower than 1500 px, whose texture comes out soft. description: what you see (type, cut, fabric, details: rips, fringe, prints, pockets) for later steps. design: the clothing_design id made from these photos. views: the side each photo shows, in order (front, back, left, right; null = as analysed). Product photos often have no head: the person is then not found, the body points come from the garment outline (pointsFrom: “outline”) and front vs back cannot be told apart, so ALWAYS check the side on the overlays and set views (pockets on the back, fly in front). Best photos: plain light background, the whole garment with the hem, straight on, even light, no hands on the garment. Without images: returns the job as it is. Next: pick a base model (clothing_bases / clothing_game_list), design it (clothing_design), then clothing_compare until the numbers are good, and only then show it to the user.

  • id string
  • images? string[]
  • replace? boolean
  • kind? string
  • sex? m | f
  • description? string
  • design? string
  • remove? number[]
  • views? enum[]
  • split? boolean

clothing_compare

Compares a clothing_design (the last preview with build: false, or the saved one) with the photos of a clothing_photo_job: the garment on the body rendered from the same side as each photo, fitted to the photo by the joints (hips, knees, ankles; shoulders, elbows for tops) and laid over it. Returns one image (per photo: photo | render on the photo | outline difference: red = only in the photo, blue = only in the render) and numbers: iou = outline agreement 0..1 (part in common / union), and per zone (thigh/shin top/bottom, sleeves, torso): dE = colour difference of the zone averages (Lab), contrast [photo, render] = how varied the brightness is (marbling, stains), bright [photo, render] = share of whitish pixels (threads, rips, prints). The render uses the preview light, not the game light: read dE as a direction (too dark, too blue), not an exact match. Use it after every design change: change the base or cut when iou is low or red/blue areas are large, the fabric colours when dE is high, the amount of rips when bright differs. Show the garment to the user only when the numbers stop improving.

  • design string
  • job string
  • photos? number[]

clothing_from_photos

Makes the garment from the photos of a clothing_photo_job on a game base model from the project: the cut fitted to the outline in the photos (trousers: wider or baggier legs, never narrower than the base, waist and hips stay so they sit on the body), the texture from the photo pixels (each point of the model takes the colour from the photo that faces it; seams, pockets and stitching from the base texture) and 3D threads where the photos show threads sticking out of the outline (frayed jeans). Every photo needs its side (views in clothing_photo_job). base (optional): a base from the project; without it the studio compares the outlines in the photos with every game model of that kind, imports the closest one and says which others were close (pass one of them as base to try it). Works for every kind: clothes on the body (tops by torso and each sleeve), shoes (photos of one right shoe), chains, bags, masks, and props (hats, glasses, earrings, watches; their rotation is found from the photos). The result is a normal clothing_design (one image layer over the whole texture, plus the cut and threads), so you can fix it like any other design. build: false = preview only. Then check it with clothing_compare and in game with clothing_wear.

  • job string
  • id string
  • base? string
  • name? string
  • photos? number[]
  • build? boolean

clothing_view

A custom clothing design (layers with id and position, to change through clothing_design), the texture preview and the 3D model from four sides (accessories and shoes also from the top and bottom). angles: custom 3D view angles, up to 6: [{yaw: 0 front, 90 character’s left side, 180 back, 270 right side; pitch: 90 from the top, -90 from below}].

  • id string
  • angles? object[]

clothing_wear

Puts custom clothing (or an accessory) on the player’s character and returns photos from the game: front, back and side, the camera aimed at the clothing, moved closer when something blocks it (photos: false for no photos). check: the studio compares the photo with and without the clothing; visible: false means nothing changed in game (invisible model or texture), then look at the photos and check the base model. New clothing from free slots is put on at once. When the game does not have the clothing yet (free slots of this base used up, or new variants beyond those the game knows), the studio reconnects the player by itself and waits for the character, about 1–2 min (reconnect: false reports an error instead). For a shirt or jacket it removes the undershirt (undershirt: false keeps it). arms: the character’s arms number (component 3) when the arms clip through the sleeves or are missing. variant: colour variant (number or name from clothing_list). save: true saves the character’s appearance with the project’s appearance script (the appearance.save capability of its adapter), so the clothing stays after rejoining. Returns gameNumber: the in-game number under which the clothing is in the clothing shop menu (custom clothing is at the end of the list for its kind).

  • id string
  • player? number
  • undershirt? boolean
  • variant? union
  • arms? number
  • save? boolean
  • photos? boolean
  • reconnect? boolean

clothing_list

Custom clothing and accessories of the project (the studio_clothing resource): id, character, kind, collection, model number and Lua to put it on (wear; accessories with the prop native). freeSlots: free slots per base model (hot reload: that many new garments of this base the game shows without rejoining, if the player joined after they were built).

clothing_export

A clothing version for the production server in /export/studio_clothing: without the hot reload free slots at the end of the lists (they would show in the clothing shop), clothing numbers the same as in the project. Copy this folder to the server instead of resources/[my]/studio_clothing. The project in the studio does not change.

clothing_remove

Removes custom clothing from the project and rebuilds studio_clothing. Its slot stays free (for the next new garment), the numbers of the others do not change.

  • id string

tattoo_design

Designs a custom tattoo and saves it in the studio_tattoos resource (addon, collection studio_tattoos_overlays); it also goes to the tattoo shop when the project’s appearance script has one (tattooShop in its adapter). Returns three things: the design itself, a 3D preview of the character with the tattoo (front, back, sides, close-up) and notes. Look at the preview and fix the placement or size before you consider the tattoo done; then tattoo_wear shows it in game. id: lowercase letters, digits, _. name: name in the shop. gender: male, female or both (default). layers (bottom first): the design in a square, position and size in fractions of the square (x, y centre 0..1, size width 0..1, default 0.5, 0.5, 1), rotation (degrees), opacity: {type:“svg”, svg: SVG code with a viewBox or an .svg path} (best for tattoos: sharp lines, gradient shading); {type:“image”, image: PNG/JPG path, removeBackground: true removes a solid background}; {type:“text”, text (\n new line), font, color, bold, italic, outline}. The design is cropped to its content, so empty margins do not change the size. ink: “color” (colours as in the design, default) or “black” (ink: dark areas cover, light ones are transparent, good for black-and-white images). opacity 0.1..1 (default 0.95). place: zone (torso, head, left_arm, right_arm, left_leg, right_leg; the character’s left/right), side (front, back, left, right; on arms and legs also outer and inner) or around (0..1, position around the zone’s circumference), height 0..1 (0 the bottom of the zone: waist, wrist, ankle; 1 the top: neck, shoulder, hip; default 0.6), size: width on the skin in cm (default 12; chest about 35 cm wide, forearm about 8 cm), rotation (degrees, clockwise, looking at the skin), flip, flipV (upside down), stretch (height relative to the design proportions, 0.2..5). The tattoo stays on its body part: what sticks out beyond it is clipped (notes say how much). spill: true only on an explicit request for a design across the boundary (e.g. from the shoulder onto the back). A next call with the same id changes only the given fields (place merges with the previous one), layers replaces the design. art: design editor layers (what a person does in the Tattoos tab), drawn over layers on a 1024 x 1024 px square; x, y is the layer centre, w, h the size in px, rotation, opacity 0..1, blend (multiply, screen, overlay…), flipX, flipY, hidden: {kind:“image”, src: path (e.g. gta/… from tattoo_catalog, images/… from tattoo_view) or data URL}; {kind:“text”, text, font, color, h = letter height, bold, italic, outline (colour), arc (arc degrees: positive up), shadow {color,x,y,blur}}; {kind:“shape”, shape: rect|ellipse|triangle|star|heart|line, fill (colour or null), stroke, strokeWidth, radius}. art replaces all editor layers; omitted, they stay; art: [] removes them. To fix a design made in the studio: tattoo_view (full art), change it and send back the whole art. A tattoo from the game catalog: layers [{type:“image”, image:“gta/…png”}] or art with src gta/…, placement from tattoo_catalog (place). build: false = preview only. Hot reload: the collection has free slots in every zone that the game knows from joining, so a new tattoo and every change reach the game live; when free ones run out, tattoo_wear reconnects the player. The studio builds the body mesh from the game files on first use.

  • id string
  • name? string
  • gender? male | female | both
  • layers? object[]
  • art? object[]
  • place? torso | head | left_arm | right_arm | left_leg | right_leg
  • ink? color | black
  • opacity? number
  • build? boolean

tattoo_wear

Puts a custom tattoo on the player’s character and returns photos from the game (close-up, from afar, from the side). For the photos it removes clothing that covers it (undress: false keeps it). check: comparison of the photo with and without the tattoo. save: true saves it in the character’s appearance (the appearance.addTattoo capability of the appearance script’s adapter), so it stays after rejoining. When the game does not know the tattoo yet (free slots used up), it reconnects the player and waits (reconnect: false reports an error).

  • id string
  • player? number
  • undress? boolean
  • save? boolean
  • photos? boolean
  • reconnect? boolean

tattoo_list

Custom tattoos of the project (the studio_tattoos resource): id, name, zone, gender, in-game names (collection, male, female) and Lua to put it on. free: free slots per zone (hot reload). bodies: whether the studio already has the male and female body meshes (from the game files). shop: state of the list in the appearance script’s tattoo shop.

tattoo_view

A tattoo design to fix with tattoo_design: layers (SVG shortened), art (full editor layers; images as images/… paths in the project, send them back unchanged) and place.

  • id string

tattoo_catalog

Ready-made GTA tattoos (catalog from the game files; the studio loads it with tattoo_catalog_import or in the studio: Tattoos, + From catalog). Game files have only technical names (e.g. Biker Tat 012), so pick a design from the thumbnail sheet (numbers match nr in the list); query narrows by pack or name (biker, lowrider, 012), zone by body part, offset scrolls. Returns a list (id, name, collection, zone, genders, image, names: in-game names for AddPedDecorationFromHashes(collection, name), place: the same placement in studio settings) and a numbered thumbnail sheet. Take a design into your own tattoo with tattoo_design: layers [{type:“image”, image}] and place (you can move it, change it, add text). imported: false = the catalog is empty, load it with tattoo_catalog_import.

  • query? string
  • zone? torso | head | left_arm | right_arm | left_leg | right_leg
  • offset? number
  • limit? number
  • sex? m | f

tattoo_catalog_import

Loads the tattoo catalog from the game (base game and DLC packs): _overlays.xml lists and tattoo textures straight from the GTA V archives. Takes up to a few minutes. dir: instead of the archives, a folder with files extracted with OpenIV or CodeWalker (_overlays.xml lists from common/data/effects/peds and the tattoo .ytd files; subfolders are searched). Replaces the previous catalog (one for all projects, in the studio’s data).

  • dir? string

tattoo_remove

Removes a custom tattoo. Its slot in the collection stays free (the in-game names of the others do not change).

  • id string

FiveM docs and natives

kb_framework_api

The framework API exactly in the version installed in the project (studio.lock): exports, network events, callbacks and framework object functions (e.g. xPlayer.setJob, QBCore.Functions.GetPlayer), with file, line, signature and the doc comment from the code. Search by words, e.g. “SetJob”, “money”, “callback character”. kind narrows the type.

  • query string
  • kind? export | event | callback | function
  • limit? number

Searches FiveM natives in the current Cfx.re documentation (refreshed daily). query: part of the name (GetEntityCoords, coords) or words from the description. side: client or server, to get only natives available on that side. Returns names to call from Lua, signatures and short descriptions.

  • query string
  • side? client | server
  • limit? number

Searches the current FiveM documentation (docs.fivem.net: scripting manual, server configuration, OneSync, state bags, buckets, NUI, assets). Returns pages with title, address, path for kb_doc and an excerpt.

  • query string
  • limit? number

kb_doc

A whole FiveM documentation page as markdown. path: path from kb_docs_search (e.g. “scripting-manual/networking/state-bags.md”).

  • path string

kb_native

Full description of one native: parameters with types and descriptions, result, side (client/server/shared), example. name: the Lua name, the documentation name or the hash.

  • name string

Shared server and production

remote_status

Shared server of the open project (the project is a copy of a server on a VPS that a team works on at the same time): connection, team members online, files waiting to be sent, edit conflicts, and the instances on that server (dev = the shared server, prod = production) with their state and current release. Returns null for a local project.

remote_update_agent

Updates the Webexe Studio agent on the shared server VPS to the version this studio brings (remote_status: agent.version below agent.latest). Owner only; logs in over SSH with the studio key, keeps members, instances and the panel. Server instances restart, so ask the user first.

deploy_run

Deploys the shared server (dev) to a production instance: commits the current files on the VPS, copies them into a new release, runs db/migrations on the production database and restarts production. Players on production are disconnected for a moment. Ask the user before deploying.

  • to string: production instance id, e.g. “prod”
  • message string: what changed, shown in the release list

deploy_releases

Releases of a production instance (number, commit, time, who, message) and which one runs now.

  • instance string

deploy_rollback

Switches a production instance to an earlier (or later) release and restarts it. Files only: database changes from migrations stay. Ask the user first.

  • instance string
  • release number

prod_logs

Last console lines of a production instance on the shared server.

  • instance string
  • lines? number

prod_server

Starts, stops or restarts a production instance on the shared server.

  • instance string
  • action start | stop | restart

prod_players

Players on a production instance now (server ID, name, ping, license, play time, warnings), reported by webexe_admin.

  • instance string

prod_player

A production player from the panel database: by license (identifiers, hardware tokens, warnings, bans, notes, recent sessions), or a search by name or identifier.

  • license? string
  • search? string

prod_player_action

Acts on a production player: kick, warn (a screen they confirm), ban (hours or null for permanent; matches identifiers and hardware tokens), unban (ban id), message, note, announce (to all, with instance). Changes a live server people play on: ask the user first for kick, warn, ban and unban.

  • type kick | warn | ban | unban | message | note | announce
  • license? string
  • reason? string
  • hours? number
  • ban? string
  • instance? string
  • text? string

prod_player_data

A production player’s data for their privacy request: export returns everything the panel keeps about them (identifiers, hardware tokens, sessions, warnings, bans, notes, allowlist); forget deletes it (an active ban stays with its identifiers only). Always ask the user first before forget.

  • license string
  • action export | forget

prod_ops

Operations of a production instance: planned restarts and the next one, metrics of the last 24 hours (players, tick, memory, machine load, free disk), database backups.

  • instance string

prod_restart_schedule

Sets planned restarts of a production instance: times “HH:MM” (machine time), skip the next one, a one-time restart “HH:MM” (null cancels), restart up to 30 min early when empty, nightly backup time (null: none). Ask the user first.

  • instance string
  • restarts? string[]
  • skipNext? boolean
  • once? string
  • whenEmpty? boolean
  • backupAt? string

prod_backup

Makes a backup of the production database (with panel.db and the running release) now.

  • instance string

prod_panel

The server panel of the shared server (administration in a browser, Discord login). Without arguments: its addresses, or null when it is off. enable: true turns it on (owner); domain adds or changes its domain (an A record must already point at the VPS). The result says what to add when ports 80/443 belong to another proxy.

  • enable? boolean
  • domain? string

prod_restore

Restores the production database from a backup (file name from prod_ops). The server stops meanwhile and the present state is backed up first. Owner only. Always ask the user first.

  • instance string
  • file string

A question this page does not answer? Ask it on Discord.

Webexe Studio

Click to see it at 100%.