FiveM Commands & Exports — Quasar Framework (qs-core) | Quasar Store

FiveM Commands & Exports — Quasar Framework (qs-core) | Quasar Store | Quasar Store

group.admin

Command	Key	Who	Description
Player
`/cash`	—	Everyone	Shows your cash and bank balance in a notification. `qs-core`
`/givemoney <amount>`	—	Everyone	Hands that much cash to the nearest player within 3 m. Both players are notified. `qs-core`
`inventory`	`F1`	Everyone	Opens or closes the inventory (not while downed). `qs-coreinventory`
`+qs-radial`	`TAB` (hold)	Everyone	Item wheel: hold, aim at one of slots 1–5 and release to use it. `qs-coreinventory`
`qs-hotbar-1` … `qs-hotbar-5`	`1` – `5`	Everyone	Uses the item in quick slot 1–5. `qs-coreinventory`
`chatopen`	`T`	Everyone	Opens the chat box. `qs-corechat`
`/colors`	—	Everyone	Opens your personal interface colour picker. Name set by `Config.ColorCommand`; only exists while `Config.AllowColorChange = true`. `qs-core`
`/logout`	—	Everyone	Saves your character and returns you to character selection. Name set by `Config.LogoutCommand`; only exists while `Config.EnableLogout = true`. `qs-coremulticharacter`
`/introreset`	—	Everyone	Deletes your saved colours, so the intro plays again on your next connection. `qs-intro`
`/introoutfit`	—	Everyone	Setup helper: prints your ped's model, clothes and props to the F8 console in the format of qs-intro's `Config.Ped`. `qs-intro`
Roleplay
`/me <action>`	—	Everyone	Describes an action to players within 20 m: `* Name action`. `qs-rp`
`/do <description>`	—	Everyone	Describes the scene to players within 20 m: `* description (( Name ))`. `qs-rp`
`/b <message>`	—	Everyone	Local out-of-character message within 20 m: `(( Name: message ))`. `qs-rp`
`/ooc <message>`	—	Everyone	Global out-of-character message to the whole server: `(OOC) Name: message`. `qs-rp`
`/try <action>`	—	Everyone	50/50 roll shown within 20 m as `* Name action — and succeeds` or `— and fails`. `qs-rp`
`/pm <id> <message>`	—	Everyone	Private message to a player by server id. `qs-rp`
`/ame <action>`	—	Everyone	Floating text above your head for 8 seconds, seen by players within 20 m. `qs-rp`
Vehicles
`vehlock`	`U`	Players with the keys	Locks or unlocks the vehicle you are in, or the closest one within 5 m. `qs-corevehiclekeys`
`hotwire`	`G`	Driver without keys, carrying a `lockpick`	Starts the lockpick minigame. Success gives you the keys and starts the engine; failure breaks the lockpick, sets off the alarm and can alert the police. `qs-corevehiclekeys`
`/givekeys [id]`	—	Players with the keys	Shares the keys of the vehicle you are sitting in with player `id`, or with the nearest player within 5 m. `qs-corevehiclekeys`
`+qsbelt`	`B`	Driver	Toggles the seatbelt indicator on the HUD. `qs-corehud`
`/adminkeys [id]`	—	Admin (`command.adminkeys`)	Gives player `id` (default: you) the keys of the vehicle you are sitting in. `qs-corevehiclekeys`
`/car <model>`	—	Admin	Spawns a vehicle, puts you in the driver seat and gives you its keys. `qs-core`
`/dv`	—	Admin	Deletes the vehicle you are in, or the closest one within 5 m. `qs-core`
Jobs
`/cuff`	—	Job `police`	Cuffs or uncuffs the nearest player. Cuffing needs `handcuffs` (not consumed). `qs-police`
`/escort`	—	Job `police`	Starts or stops escorting the nearest cuffed player. `qs-police`
`/putincar`	—	Job `police`	Seats the nearest cuffed player in the closest vehicle, rear seats first. `qs-police`
`/outcar`	—	Job `police`	Takes the nearest cuffed player out of their vehicle. `qs-police`
`/search`	—	Job `police`	Opens the inventory of the nearest player. Confiscating an item needs them cuffed. `qs-police`
`/fine <amount> [reason]`	—	Job `police`	Fines the nearest player within 5 m. The amount (1–50,000) is taken from their bank. `qs-police`
`/impound`	—	Job `police`	Removes the closest vehicle within 5 m. `qs-police`
`/diagnose`	—	Job `ambulance`	Opens the injury report of the nearest player within 4 m, or your own. `qs-ambulance`
`/stretcher`	—	Job `ambulance`	Deploys your stretcher, or removes it if you already have one out. `qs-ambulance`
Administration
`admin`	`F6`	Admin	Opens the admin menu (players, money, jobs, items, weather, time, noclip, vehicles). `qs-admin`
`/setjob <id> <job> [grade]`	—	Admin	Sets a player's job. Grade defaults to `0`. `qs-core`
`/addmoney <id> <account> <amount>`	—	Admin	Adds money to `cash`, `bank` or `black_money`. `qs-core`
`/removemoney <id> <account> <amount>`	—	Admin	Removes money from an account (fails if the balance is too low). `qs-core`
`/giveitem <id> <item> [count]`	—	Admin	Gives an item. Count defaults to `1`. `qs-core`
`/revive [id]`	—	Admin	Revives a downed player (default: you). `qs-core`
`/kill [id]`	—	Admin	Kills a player (default: you); they go down as from any other death. `qs-core`
`/freeze <id>`	—	Admin	Freezes or unfreezes a player. `qs-core`
`/god`	—	Admin	Toggles god mode on yourself. `qs-core`
`/announce <message>`	—	Admin	Shows a notification to everyone for 8 seconds. `qs-core`
`/coords`	—	Admin	Prints your position as `vec4(x, y, z, h)` in F8 and in a notification. `qs-core`
`/tp <x> <y> <z>`	—	Admin	Teleports you to coordinates. `qs-core`
`/tpm`	—	Admin	Teleports you to your map waypoint. `qs-core`
`/goto <id>`	—	Admin	Teleports you to a player. `qs-core`
`/bring <id>`	—	Admin	Teleports a player to you. `qs-core`
`/noclip`	—	Admin	Toggles noclip (controls below). `qs-core`
`/kick <id> [reason]`	—	Admin	Kicks a player. `qs-core`
`/ban <id> [minutes] [reason]`	—	Admin	Bans and kicks a player. `0` or no minutes = permanent. `qs-core`
`/unban <license>`	—	Admin	Removes every ban of a full `license:…` identifier. `qs-core`
`/setgroup <id> <group>`	—	Admin	Saves the player's group (e.g. `admin`) and applies `group.<group>` at once, replacing their previous group. The result is printed in the server console. `qs-core`
`/removegroup <id>`	—	Admin	Deletes the player's saved group and removes it at once. `qs-core`
`/clothing`	—	Admin	Opens the full appearance editor for yourself, tattoos included. `qs-clothing`

Key mapping	Default key	Name in Key Bindings	Default set by
`inventory`	`F1`	Toggle inventory	`Config.OpenKey` in `qs-coreinventory`
`+qs-radial`	`TAB`	Item wheel	`Config.RadialKey` in `qs-coreinventory`
`qs-hotbar-1` … `qs-hotbar-5`	`1` – `5`	Use inventory slot 1 … 5	fixed
`vehlock`	`U`	Lock / unlock vehicle	`Config.LockKey` in `qs-corevehiclekeys`
`hotwire`	`G`	Hotwire vehicle	`Config.HotwireKey` in `qs-corevehiclekeys`
`+qsbelt`	`B`	Toggle seatbelt	`Config.Vehicle.beltKey` in `qs-corehud`
`chatopen`	`T`	Open chat	fixed
`admin`	`F6`	Open admin menu	`Config.OpenKey` in `qs-admin`

Key	Where	Action
`E`	Shops, garages, dealership, banks and ATMs, clothing stores, job and drug points, police station, hospital	Interact
`E`	Downed, after 20 seconds	Respawn at the nearest hospital
`G`	Downed	Call paramedics (30 second cooldown)
`X`	Any progress bar that can be cancelled	Cancel
`SPACE` / `ESC` or `BACKSPACE`	Lockpick minigame	Set a pin / give up
`E` / `G` / `H`	Next to a stretcher (EMS)	Move or drop / load or unload patient / into the ambulance or store
`W` `A` `S` `D`, `Q` / `E`	Noclip	Move, up / down
Mouse wheel / wheel click	Noclip	Change speed / reset speed
`SHIFT` / `ALT` / `CTRL`	Noclip	2× / 4× / 0.25× speed
`BACKSPACE` / `ESC`	Spectating from the admin menu	Stop spectating

GetPlayer

lua

exports['qs-core']:GetPlayer(source)

Parameters: source — player server id.

Returns: a player table, or nil if no character is loaded. It holds source, citizenid, PlayerData (a copy taken at the moment of the call: citizenid, license, name, charinfo, money, job, inventory, metadata, position, skin, is_dead, cid) and every player method: getCitizenId, getCharInfo, getPed, getCoords, getMoney, addMoney, removeMoney, setMoney, getJob, setJob, setJobDuty, getGang, setGang, isDead, getMetadata, setMetadata, getSkin, setSkin, addItem, removeItem, hasItem, canCarryItem, getItemCount, getSlotView, getItemBySlot, setItemInfo, setBusy, emit and save.

Example: local player = exports['qs-core']:GetPlayer(source); player:addMoney('cash', 100, 'reward')

GetPlayerByCitizenId

lua

exports['qs-core']:GetPlayerByCitizenId(citizenid)

Parameters: citizenid — the character id (QS followed by 6 characters).

Returns: the same player table as GetPlayer, or nil when that character is not online. For offline characters use GetOfflinePlayerByCitizenId.

Example: local player = exports['qs-core']:GetPlayerByCitizenId('QSA1B2C3')

GetPlayers

lua

exports['qs-core']:GetPlayers()

Parameters: none.

Returns: a list of player tables, one per loaded character.

Example: for _, p in ipairs(exports['qs-core']:GetPlayers()) do print(p.source, p.citizenid) end

GetCharacters

lua

exports['qs-core']:GetCharacters(source)

Parameters: source — player server id.

Returns: the account's characters ordered by slot, each { citizenid, cid, name, charinfo, money, job, skin, position }. Empty table if the player has no license identifier.

Example: local chars = exports['qs-core']:GetCharacters(source)

CreateCharacter

lua

exports['qs-core']:CreateCharacter(source, charinfo, skin?, cid?)

Parameters: charinfo — { firstname, lastname, dob, sex, nationality }; skin — optional appearance table; cid — optional slot number.

Returns: the new character's data, or nil, err with err = 'no_license', 'max_characters' (limit Config.MaxCharacters) or 'slot_taken'. The character starts with , and . It is not loaded — call next.

LoadCharacter

lua

exports['qs-core']:LoadCharacter(source, citizenid, isNew?)

Parameters: citizenid — a character owned by this player; isNew — true right after creation (starting items, editor).

Returns: true, or false, err with err = 'no_license', 'not_found' or 'not_owner'. Fires qs:server:playerLoaded, and spawns the player.

Logout

lua

exports['qs-core']:Logout(source)

Parameters: source — player server id.

Returns: true, or false if no character was loaded. Saves, unloads the character and fires qs:server:playerUnloaded and qs:client:playerUnloaded. With qs-coremulticharacter the selection screen opens again.

Example: exports['qs-core']:Logout(source)

DeleteCharacter

lua

exports['qs-core']:DeleteCharacter(citizenid)

Parameters: citizenid — character to delete.

Returns: nothing. Deletes the row from players without any ownership check, so check it yourself first (for example against GetCharacters).

Example: exports['qs-core']:DeleteCharacter('QSA1B2C3')

GetOfflinePlayerByCitizenId · SaveOfflinePlayer

lua

exports['qs-core']:GetOfflinePlayerByCitizenId(citizenid)
exports['qs-core']:SaveOfflinePlayer(citizenid, patch)

Parameters: citizenid — any character; patch — table with the top-level fields to replace (money, job, metadata, charinfo, inventory, position, skin…).

Returns: returns read from the database, or . returns once written. Use them for offline characters only: an online character is saved over by its own next save.

SetPlayerDead

lua

exports['qs-core']:SetPlayerDead(source, state)

Parameters: state — true puts the player in the downed state, false revives them.

Returns: true, or false if no character is loaded.

Example: exports['qs-core']:SetPlayerDead(source, false)

GetMoney

lua

exports['qs-core']:GetMoney(source, account)

Parameters: account — an account from Config.Accounts: cash, bank or black_money.

Returns: the balance, or 0.

Example: local bank = exports['qs-core']:GetMoney(source, 'bank')

AddMoney

lua

exports['qs-core']:AddMoney(source, account, amount, reason?)

Parameters: account — cash, bank or black_money; amount — greater than 0; reason — optional text passed to qs:server:moneyChange.

Returns: true, or false if the account does not exist or the amount is not positive.

Example: exports['qs-core']:AddMoney(source, 'bank', 500, 'bonus')

RemoveMoney

lua

exports['qs-core']:RemoveMoney(source, account, amount, reason?)

Parameters: same as AddMoney.

Returns: true, or false if the balance is too low, the account does not exist or the amount is not positive.

Example: if exports['qs-core']:RemoveMoney(source, 'cash', 250, 'shop') then ... end

SetMoney

lua

exports['qs-core']:SetMoney(source, account, amount)

Parameters: amount — 0 or more.

Returns: true or false. It does not fire qs:server:moneyChange.

Example: exports['qs-core']:SetMoney(source, 'black_money', 0)

GetAccountMoney · AddAccountMoney · RemoveAccountMoney · SetAccountMoney

lua

exports['qs-core']:GetAccountMoney(source, account)
exports['qs-core']:AddAccountMoney(source, account, amount, reason?)
exports['qs-core']:RemoveAccountMoney(source, account, amount, reason?)
exports['qs-core']:SetAccountMoney(source, account, amount)

Parameters: account — cash (alias money) and bank are the same balances as GetMoney; any other name, such as crypto, is an extra account stored in the character's metadata (accounts_extra) and created on first use.

a number for , / for the others. These are the functions the ESX and QBCore bridges use. For , use / — that is the balance pays into.

SetJob

lua

exports['qs-core']:SetJob(source, name, grade?)

Parameters: name — a job that exists in qs-core/shared/jobs.lua or was registered at runtime; grade — defaults to 0. A grade that does not exist falls back to the lowest grade.

Returns: true, or false for an unknown job. Fires qs:server:jobChange.

Example: exports['qs-core']:SetJob(source, 'police', 1)

RegisterJob · RegisterJobs

lua

exports['qs-core']:RegisterJob(name, def)
exports['qs-core']:RegisterJobs({ [name] = def, ... })

Parameters: def — { label, defaultDuty, grades = { [0] = { name, label, salary, isBoss } } }. Missing label becomes the name; missing grades becomes one grade employee with salary 0. Server side only, and only until the next restart.

Returns: true, or false for invalid arguments. Registering an existing name replaces it.

Example: exports['qs-core']:RegisterJob('mechanic', { label = 'Mechanic', grades = { [0] = { name = 'apprentice', label = 'Apprentice', salary = 300 } } })

UpdateJob · RemoveJob · GetJobs

lua

exports['qs-core']:UpdateJob(name, def)
exports['qs-core']:RemoveJob(name)
exports['qs-core']:GetJobs()

Parameters: name — an existing job; def — full definition (it replaces, it does not merge).

Returns: UpdateJob and RemoveJob return false if the job does not exist. GetJobs returns every job keyed by name.

Example: local jobs = exports['qs-core']:GetJobs(); print(jobs.police.label)

SetJobDuty

lua

exports['qs-core']:SetJobDuty(source, onDuty)

Parameters: onDuty — boolean.

Returns: true or false. Stores the flag in the character's metadata and job, fires qs:server:jobChange and the client qs:client:onDutyUpdate. The QBCore bridge's Player.Functions.SetJobDuty uses it.

Example: exports['qs-core']:SetJobDuty(source, true)

GetPlayersOnDuty

lua

exports['qs-core']:GetPlayersOnDuty(jobName)

Parameters: jobName — job name.

Returns: two values: a list of server ids and their count, for players with that job whose duty flag is not false.

Example: local sources, count = exports['qs-core']:GetPlayersOnDuty('police')

SetGang · GetGangForPlayer

lua

exports['qs-core']:SetGang(source, name, grade?)
exports['qs-core']:GetGangForPlayer(source)

Parameters: name — a gang name in lower case; grade — defaults to 0.

Returns: SetGang returns true/false and fires qs:server:gangChange. GetGangForPlayer returns { name, label, isboss, grade = { name, level } }, or the none gang.

RegisterGang · RegisterGangs · GetGang · GetGangs · RemoveGang

lua

exports['qs-core']:RegisterGang(name, def)
exports['qs-core']:RegisterGangs({ [name] = def, ... })
exports['qs-core']:GetGang(name)
exports['qs-core']:GetGangs()
exports['qs-core']:RemoveGang(name)

Parameters: def — { label, grades = { [0] = { name, label, isBoss } } }. Use lower-case names. Missing grades become one grade member.

Returns: true/false; GetGang returns the definition or nil. refuses . Available on the client too, with its own copy of the list.

GetMetadata · SetMetadata

lua

exports['qs-core']:GetMetadata(source, key?)
exports['qs-core']:SetMetadata(source, key, value)

Parameters: key — any metadata key (hunger, thirst, gang, onduty, accounts_extra or your own); without a key GetMetadata returns the whole table.

Returns: the value (a stored false comes back as nil); SetMetadata returns true/false and sends qs:metadata:set to the player, which the HUD uses for hunger and thirst.

Example: exports['qs-core']:SetMetadata(source, 'hunger', 100)

GetSkin · SetSkin

lua

exports['qs-core']:GetSkin(source)
exports['qs-core']:SetSkin(source, skin)

Parameters: skin — the appearance table used by qs-clothing.

Returns: GetSkin returns the table or nil; SetSkin returns true/false, applies the skin on the player at once and stores it with the next character save.

Example: local skin = exports['qs-core']:GetSkin(source)

RegisterItem · RegisterItems

lua

exports['qs-core']:RegisterItem(name, def)
exports['qs-core']:RegisterItems({ [name] = def, ... })

Parameters: def — { label, weight, useable, description, image, stack, unique, weapon, ammo }. Weight is in grams; useable = true is required for the item to do anything when used; weapon = 'WEAPON_X' makes it equip a weapon. Registering an existing name replaces it.

Returns: RegisterItem returns true/false. Register items on the server: the client keeps a separate catalogue.

Example: exports['qs-core']:RegisterItem('pizza', { label = 'Pizza', weight = 500, useable = true, description = 'A hot slice.' })

GetItem · GetItems · UpdateItemDefinition · RemoveItemDefinition

lua

exports['qs-core']:GetItem(name)
exports['qs-core']:GetItems()
exports['qs-core']:UpdateItemDefinition(name, def)
exports['qs-core']:RemoveItemDefinition(name)

Parameters: name — item name; def — full definition (it replaces, it does not merge).

Returns: a definition or nil; the whole catalogue; true/false (false when the item does not exist).

Example: local def = exports['qs-core']:GetItem('water'); print(def.label, def.weight)

AddItem

lua

exports['qs-core']:AddItem(source, item, count?, slot?, info?)

Parameters: count — defaults to 1; slot — preferred slot; info — per-item metadata table (serial numbers, evidence data…).

Returns: true or false. With qs-coreinventory it fails for unknown items, when the player would go over the weight limit (Too heavy to carry) or has no room (Inventory full).

Example: exports['qs-core']:AddItem(source, 'water', 2)

RemoveItem

lua

exports['qs-core']:RemoveItem(source, item, count?, slot?)

Parameters: count — defaults to 1; slot — take only from that slot.

Returns: true, or false if the player does not have enough.

Example: exports['qs-core']:RemoveItem(source, 'lockpick', 1)

HasItem · GetItemCount · CanCarryItem

lua

exports['qs-core']:HasItem(source, item, count?)
exports['qs-core']:GetItemCount(source, item)
exports['qs-core']:CanCarryItem(source, item, count?)

Parameters: count — defaults to 1.

Returns: HasItem and CanCarryItem return booleans (CanCarryItem checks weight and free space without changing anything); GetItemCount returns the total across all slots.

Example: if exports['qs-core']:CanCarryItem(source, 'stone', 3) then exports['qs-core']:AddItem(source, 'stone', 3) end

GetSlotView · GetItemBySlot

lua

exports['qs-core']:GetSlotView(source)
exports['qs-core']:GetItemBySlot(source, slot)

Parameters: slot — slot number.

Returns: GetSlotView returns every slot, each false (empty) or { slot, name, label, count, weight, useable, description, image, max, info } with qs-coreinventory. GetItemBySlot returns one of those entries or nil.

Example: local item = exports['qs-core']:GetItemBySlot(source, 1)

SetItemInfo

lua

exports['qs-core']:SetItemInfo(source, slot, info)

Parameters: info — the new metadata table for the item in that slot (replaces the old one).

Returns: true or false.

Example: exports['qs-core']:SetItemInfo(source, slot, { serial = 'AB1234' })

RegisterUsableItem

lua

exports['qs-core']:RegisterUsableItem(item, handler)

Parameters: handler — with qs-coreinventory, function(source, slot, info). The item must be registered with useable = true. The inventory does not remove the item; do it in the handler if it is consumable. One handler per item: the last registration wins.

Returns: true. Calls made before the inventory has started are queued and applied when it starts.

Example: exports['qs-core']:RegisterUsableItem('pizza', function(source, slot) exports['qs-core']:RemoveItem(source, 'pizza', 1, slot) end)

RegisterStash

lua

exports['qs-core']:RegisterStash(id, label?, slots?, maxWeight?, columns?)

Parameters: id — unique stash id. qs-coreinventory defaults: label Stash, 50 slots, 100000 g, 5 columns. Contents are saved in stash_inventories.

Returns: true or false. Players open it through a client stash zone (RegisterStashZone) or qs-coreinventory's OpenStash.

SetBusy

lua

exports['qs-core']:SetBusy(source, ms)

Parameters: ms — milliseconds during which the player cannot use items.

Returns: nothing. Only has an effect with qs-coreinventory.

Example: exports['qs-core']:SetBusy(source, 3000)

GetInventory · SetInventory

lua

exports['qs-core']:GetInventory(source)
exports['qs-core']:SetInventory(source, list)

Parameters: list — the raw slot list stored in players.inventory, each entry { name, count, info } or false.

Returns: the list / true. Prefer AddItem and RemoveItem, which also refresh the player's inventory screen.

Example: exports['qs-core']:SetInventory(source, {})

GetCitizenVehicles

lua

exports['qs-core']:GetCitizenVehicles(citizenid)

Parameters: citizenid — character id.

Returns: every vehicle row owned by that character, with props already decoded. GetOwnedVehicles(citizenid) is the same function under its older name.

Example: local cars = exports['qs-core']:GetCitizenVehicles(player.citizenid)

GetGarageVehicles

lua

exports['qs-core']:GetGarageVehicles(citizenid, garage)

Parameters: garage — a garage id, such as legion_square.

Returns: the character's rows whose garage equals that id.

Example: local cars = exports['qs-core']:GetGarageVehicles(cid, 'pillbox_hill_garage')

GetVehicleByPlate · PlateExists

lua

exports['qs-core']:GetVehicleByPlate(plate)
exports['qs-core']:PlateExists(plate)

Parameters: plate — plate text without trailing spaces.

Returns: the row or nil; true/false.

Example: local row = exports['qs-core']:GetVehicleByPlate('QS4F2K9')

CreateOwnedVehicle

lua

exports['qs-core']:CreateOwnedVehicle(data)

Parameters: data — { citizenid, license, plate, model, garage, state, fuel, engine, body, props }. Defaults: garage legion, state 1, fuel 100, engine and body 1000.0, props {}. A garage id that is not configured in qs-garage makes the car appear in every garage until it is stored once.

Returns: the new row id.

Example: exports['qs-core']:CreateOwnedVehicle({ citizenid = player.citizenid, license = player.PlayerData.license, plate = 'QS12345', model = 'sultan' })

UpdateOwnedVehicle · SetVehicleState

lua

exports['qs-core']:UpdateOwnedVehicle(plate, data)
exports['qs-core']:SetVehicleState(plate, state, garage?)

Parameters: data — { garage, state, fuel, engine, body, props }. UpdateOwnedVehicle writes all six columns, so read the row first and pass every field. SetVehicleState changes only state (and garage when given).

Returns: nothing.

Example: exports['qs-core']:SetVehicleState('QS12345', 1, 'legion_square')

SpawnVehicle

lua

exports['qs-core']:SpawnVehicle(source, model, coords?, warp?)

Parameters: model — name or hash; coords — vec4 or { x, y, z, w }, defaults to the player's position; warp — put the player in the driver seat.

Returns: the vehicle's network id, or nil if it could not be created. It does not give keys — see qs-corevehiclekeys below.

Example: local netId = exports['qs-core']:SpawnVehicle(source, 'adder', nil, true)

GetPlayerVehiclesQBShape

lua

exports['qs-core']:GetPlayerVehiclesQBShape(citizenid)

Parameters: citizenid — character id.

Returns: the character's vehicles shaped like QBCore's player_vehicles rows: citizenid, license, vehicle, hash, mods, plate, garage, fuel, , , .

HasPermission

lua

exports['qs-core']:HasPermission(source, permission)

Parameters: permission — a name such as admin, or a list of names (any match passes).

Returns: true for the console, for user, or when the player has the ACE <permission>, qbcore.<permission> or group.<permission>. admin, god and mod also pass with group.admin or command.

Example: if exports['qs-core']:HasPermission(source, { 'admin', 'mod' }) then ... end

AddPermission · RemovePermission · GetPermission

lua

exports['qs-core']:AddPermission(source, permission)
exports['qs-core']:RemovePermission(source, permission)
exports['qs-core']:GetPermission(source)

Parameters: permission — a name such as mod.

Returns: AddPermission / RemovePermission return true/false and add or remove the ACEs qbcore.<permission> and group.<permission> on the player's license until the next restart. returns with only the ones the player has. For a group that survives restarts, use .

Setting a saved group from a script

lua

ExecuteCommand(('setgroup %d %s'):format(targetId, 'admin'))

Parameters: there is no export for groups; run the command, which a resource executes with console rights. This is what the admin menu does.

Returns: nothing. The group is stored in player_groups, applied at once and re-applied every time the player connects.

Example: ExecuteCommand(('removegroup %d'):format(targetId))

IsPlayerBanned

lua

exports['qs-core']:IsPlayerBanned(licenseOrSource)

Parameters: a server id or a full license:… identifier.

Returns: banned, reason, expiresUnix. Every active ban of the license counts, and a permanent ban wins over a temporary one; expiresUnix is the end as a Unix timestamp, or nil for a permanent ban. false when there is no active ban, and always false when Config.EnableBans = false.

Example: local banned, reason, expires = exports['qs-core']:IsPlayerBanned(source)

AddBan

lua

exports['qs-core']:AddBan(source, minutes, reason, adminName)

Parameters: minutes — 0 or nil for a permanent ban; adminName — stored as banned_by.

Returns: true, or false if the player has no license. The player is kicked immediately.

Example: exports['qs-core']:AddBan(source, 1440, 'Exploiting', 'Anticheat')

RemoveBan · ExploitBan

lua

exports['qs-core']:RemoveBan(license)
exports['qs-core']:ExploitBan(source, origin?)

Parameters: license — full license:… identifier; origin — text stored as the reason.

Returns: RemoveBan deletes every ban of that identifier and returns true. ExploitBan bans permanently with banned_by = 'Anti Cheat'.

Example: exports['qs-core']:ExploitBan(source, 'triggered protected event')

RegisterCallback

lua

exports['qs-core']:RegisterCallback(name, function(source, ...) return ... end)

Parameters: name — callback name; the handler receives the player and the client's arguments, and whatever it returns is sent back.

Returns: nothing. The client calls it with TriggerCallback.

Example: exports['qs-core']:RegisterCallback('myshop:getCash', function(source) return exports['qs-core']:GetMoney(source, 'cash') end)

RegisterQBCallback

lua

exports['qs-core']:RegisterQBCallback(name, function(source, cb, ...) cb(...) end)

Parameters: QBCore-style handler that answers through cb.

Returns: nothing. Clients call it with TriggerQBCallback or QBCore.Functions.TriggerCallback.

Example: exports['qs-core']:RegisterQBCallback('myshop:getBank', function(source, cb) cb(exports['qs-core']:GetMoney(source, 'bank')) end)

Notify a player from the server

lua

TriggerClientEvent('qs:client:notify', source, message, type?, duration?, title?)

Parameters: type — success, error, info (default) or primary; duration — milliseconds, default 4000; title — optional, defaults to a localized title for the type. Use -1 as source to notify everyone. There is no server export: this event is the server API.

Returns: nothing.

GetCoreObject

lua

exports['qs-core']:GetCoreObject()

Parameters: none.

Returns: the core table: Players, Config, Jobs, Gangs, Utils and the core functions. Read config values from it; for players, use GetPlayer — player objects taken from this table in another resource have no methods.

Example: local QS = exports['qs-core']:GetCoreObject(); print(QS.Config.MaxCharacters)

RateLimit

lua

exports['qs-core']:RateLimit(key, max, windowMs)

Parameters: key — bucket name; max — calls allowed per window; windowMs — window length. Buckets are shared by every resource, so prefix keys with your resource name.

Returns: true while under the limit, false when over it.

Example: if not exports['qs-core']:RateLimit(('myshop:buy:%d'):format(source), 1, 1000) then return end

RegisterFrameworkCommand · RefreshCommands

lua

exports['qs-core']:RegisterFrameworkCommand(name, help, arguments, argsrequired, callback, permission?)
exports['qs-core']:RefreshCommands(source)

Parameters: QBCore-style command (this is what QBCore.Commands.Add calls): arguments — { { name, help } } for the chat suggestion; argsrequired — refuse with fewer arguments; callback(source, args, raw); permission — defaults to user, checked with HasPermission.

Returns: nothing. re-sends every chat suggestion to a player (done automatically when a character loads).

GetColors

lua

exports['qs-core']:GetColors()

Parameters: none.

Returns: on the server, the default palette Config.Theme (primary, accent, text, panel, health…).

Example: local theme = exports['qs-core']:GetColors()

GetPlayerData

lua

exports['qs-core']:GetPlayerData()

Parameters: none.

Returns: the local character, or nil before a character is loaded: { source, citizenid, license, name, charinfo, money, job, metadata, gang, onduty, position, skin, is_dead, isNew }. Money, job, gang, duty and metadata stay up to date.

Example: local data = exports['qs-core']:GetPlayerData(); print(data.job.label)

Notify

lua

exports['qs-core']:Notify(message, type?, duration?, title?)

Parameters: type — success, error, info (default) or primary; duration — milliseconds, default 4000.

Returns: nothing.

Example: exports['qs-core']:Notify('Vehicle repaired', 'success')

Progress

lua

exports['qs-core']:Progress({ duration = 3000, label = '', disableMovement = false, canCancel = false })

Parameters: duration — milliseconds; label — text on the bar; disableMovement — block walking, sprinting and jumping; canCancel — allow X to cancel. The call waits until the bar ends.

Returns: true when completed, false when cancelled or when another bar is already running.

Example:

CancelProgress · IsBusy

lua

exports['qs-core']:CancelProgress()
exports['qs-core']:IsBusy()

Parameters: none.

Returns: IsBusy returns true while a progress bar is running.

Example: if exports['qs-core']:IsBusy() then return end

Lockpick

lua

exports['qs-core']:Lockpick(rounds?)

Parameters: rounds — 1 to 6, default 3. The player sets pins with SPACE and gives up with ESC or BACKSPACE; 30 seconds of inactivity counts as a failure. The call waits until it ends.

Returns: true on success, false otherwise.

Example: if exports['qs-core']:Lockpick(4) then ... end

HasItem · GetItemCount

lua

exports['qs-core']:HasItem(item, count?)
exports['qs-core']:GetItemCount(item)

Parameters: count — defaults to 1.

Returns: boolean / number, read from the active inventory's client copy.

Example: if exports['qs-core']:HasItem('lockpick') then ... end

RegisterStashZone · RemoveStashZone

lua

exports['qs-core']:RegisterStashZone(id, coords, opts?)
exports['qs-core']:RemoveStashZone(id)

Parameters: id — a stash registered on the server; coords — vector3; opts.radius — default 2.0 m. With qs-coreinventory, opening the inventory inside the zone shows the stash as the second panel.

Returns: true or false.

Example: exports['qs-core']:RegisterStashZone('mechanic_locker', vector3(-347.2, -133.6, 39.0), { radius = 1.5 })

TriggerCallback · TriggerQBCallback

lua

exports['qs-core']:TriggerCallback(name, function(...) end, ...)
exports['qs-core']:TriggerQBCallback(name, function(...) end, ...)

Parameters: name — a callback registered with RegisterCallback / RegisterQBCallback; extra arguments are sent to the handler.

Returns: nothing; the function receives the server's answer.

Example: exports['qs-core']:TriggerCallback('myshop:getCash', function(cash) print(cash) end)

IsDead · SetDownAnimPaused

lua

exports['qs-core']:IsDead()
exports['qs-core']:SetDownAnimPaused(state)

Parameters: state — true stops the downed loop from replaying the lying animation while you play your own (the EMS stretcher uses it).

Returns: IsDead returns true while the player is downed.

Example: if exports['qs-core']:IsDead() then return end

IsNoclipActive · ToggleNoclip

lua

exports['qs-core']:IsNoclipActive()
exports['qs-core']:ToggleNoclip(state?)

Parameters: call ToggleNoclip() without arguments to toggle, or with true to turn it on. It does not check permissions — only call it for admins.

Returns: IsNoclipActive returns a boolean.

Example: if not exports['qs-core']:IsNoclipActive() then exports['qs-core']:ToggleNoclip() end

GetColors · SetClientColors · HasSavedColors

lua

exports['qs-core']:GetColors()
exports['qs-core']:SetClientColors(palette)
exports['qs-core']:HasSavedColors()

Parameters: palette — a table with the same keys as Config.Theme.

Returns: GetColors returns the player's saved palette or Config.Theme; SetClientColors applies a palette for this session only (not saved) and fires qs:client:colorsChanged; HasSavedColors tells whether the player chose their own colours.

Example:

qs-coreinventory (server)

lua

exports['qs-coreinventory']:AddItem(source, item, count, slot?, info?)
exports['qs-coreinventory']:RemoveItem(source, item, count, slot?)
exports['qs-coreinventory']:GetItemCount(source, item)
exports['qs-coreinventory']:HasItem(source, item, count?)
exports['qs-coreinventory']:CanCarryItem(source, item, count?, info?)
exports['qs-coreinventory']:GetSlotView(source)
exports['qs-coreinventory']:GetItemBySlot(source, slot)
exports['qs-coreinventory']:SetItemInfo(source, slot, info)
exports['qs-coreinventory']:RegisterUsableItem(item, function(source, slot, info) end)
exports['qs-coreinventory']:RegisterStash(id, label?, slots?, maxWeight?, columns?)
exports['qs-coreinventory']:SetBusy(source, ms)
exports['qs-coreinventory']:IsBusy(source)

The same operations as the qs-core item exports, but tied to this inventory. Prefer the qs-core versions, which keep working if you switch to qs-inventory; IsBusy exists only here.

qs-coreinventory (client)

lua

exports['qs-coreinventory']:OpenStash(id, opts?)
exports['qs-coreinventory']:RegisterStashZone(id, coords, opts?)
exports['qs-coreinventory']:RemoveStashZone(id)
exports['qs-coreinventory']:HasItem(item, count?)
exports['qs-coreinventory']:GetItemCount(item)

OpenStash opens the inventory with stash id as the second panel, from anywhere (no zone needed). It returns false if the inventory is already open. opts = { label, slots, maxWeight, columns } is only used for a stash that was not registered on the server.

qs-corevehiclekeys (client)

lua

exports['qs-corevehiclekeys']:GiveKeys(plate)
exports['qs-corevehiclekeys']:RemoveKeys(plate)
exports['qs-corevehiclekeys']:HasKeys(plate)
exports['qs-corevehiclekeys']:GetKeys()

Keys are kept per session on the client. Give keys after spawning a vehicle from your own script, or the driver cannot start it. From the server, send TriggerClientEvent('vehiclekeys:client:SetOwner', source, plate) — the same event QBCore scripts use. Example: exports['qs-corevehiclekeys']:GiveKeys(GetVehicleNumberPlateText(vehicle))

qs-clothing (client)

lua

exports['qs-clothing']:ApplyAppearance(skin, sex?)
exports['qs-clothing']:OpenCreator(sex, function(skin) end)
exports['qs-clothing']:IsCreatorOpen()

ApplyAppearance sets the freemode model and every clothing, prop and tattoo from a skin table (an empty skin applies the default look for sex). To change a player's saved appearance from the server, use qs-core SetSkin. To open the editor, trigger qs-clothing:client:open.

qs-police (server)

lua

exports['qs-police']:Alert(coords, label?)

Sends a dispatch alert — notification and flashing blip for 60 seconds — to every player with the police job. coords must be a plain table { x, y, z }; a vector3 is ignored, so convert it first. Without a label the alert reads Shots fired. Example: local c = GetEntityCoords(GetPlayerPed(source)); exports['qs-police']:Alert({ x = c.x, y = c.y, z = c.z }, 'Store robbery')

qs-banking

qs-banking has no exports. Bank balances are the qs-core bank account, so a script that pays or charges a bank account uses exports['qs-core']:AddMoney(source, 'bank', amount, reason) and RemoveMoney. Account numbers and the transaction history are kept in bank_accounts and bank_transactions.

Bridge exports (ESX, QBCore and friends)

lua

exports['es_extended']:getSharedObject()                 -- shared
exports['qb-core']:GetCoreObject()                       -- shared
exports['LegacyFuel']:GetFuel(vehicle)                   -- client
exports['LegacyFuel']:SetFuel(vehicle, fuel)             -- client, 0-100
exports['progressbar']:Progress(data, function(cancelled) end) -- client
exports['qb-management']:AddMoney(job, amount)           -- server, also GetAccount, RemoveMoney, GetGangAccount, AddGangMoney, RemoveGangMoney
exports['esx_society']:addMoney(account, amount)         -- server, also getSociety, getSocietyMoney, removeMoney
exports['qb-vehiclekeys']:GiveKeys(source, plate)        -- server; client: GiveKeys, RemoveKeys, HasKeys, GetKeys

These answer under the names ESX and QBCore scripts already call, and forward to Quasar Framework. The full list is in .

Event	Side	Arguments	When it fires
`qs:server:characterLoaded`	server	`source, { citizenid, charinfo, isNew }`	A character finished loading. The recommended hook for other resources.
`qs:server:playerLoaded`	server	`source, player`	Just before `characterLoaded`. `player` is qs-core's internal object; in another resource read the data with `GetPlayer` instead.
`qs:server:playerUnloaded`	server	`source, citizenid`	After `Logout` (for example `/logout`). Not fired on disconnect — use `playerDropped` for that.
`qs:server:playerSaved`	server	`source, PlayerData`	After every save: autosave, disconnect, logout and qs-core stop.
`qs:server:moneyChange`	server	`source, account, kind, amount, reason`	Money added or removed (`kind` = `add` / `remove`; `set` for extra accounts). Not fired by `SetMoney`.
`qs:server:jobChange`	server	`source, job`	Job or duty changed. `job` = `{ name, label, grade, gradeName, gradeLabel, salary, isBoss, onduty }`.
`qs:server:gangChange`	server	`source, gang`	Gang changed.
`qs:server:usedItem`	server	`source, item, slot, info`	A useable item that is not a weapon was used, from any inventory.
`qs:server:catalogReady`	server	—	Once, 500 ms after qs-core starts. The QBCore bridge syncs its shared items and jobs on it.

lua

AddEventHandler('qs:server:characterLoaded', function(source, data)
    if data.isNew then
        exports['qs-core']:AddMoney(source, 'bank', 1000, 'welcome bonus')
    end
end)

AddEventHandler('qs:server:usedItem', function(source, item, slot, info)
    if item ~= 'pizza' then return end
    exports['qs-core']:RemoveItem(source, 'pizza', 1, slot)
end)

Event	Side	Arguments	When it fires
`qs:client:onPlayerLoaded`	client (local)	`data` (same table as `GetPlayerData`)	The character is placed in the world, just before the screen fades in.
`qs:client:onPlayerUnloaded`	client (local)	—	After logout.
`qs:client:onJobUpdate`	client (local)	`job`	Job or duty changed.
`qs:client:onGangUpdate`	client (local)	`gang`	Gang changed.
`qs:client:onDutyUpdate`	client (local)	`onDuty`	Duty changed.
`qs:client:onDeath`	client (local)	—	The player goes down.
`qs:client:onRevive`	client (local)	—	The downed state ends (revive or hospital respawn).
`qs:client:emsCall`	client (local)	—	A downed player pressed `G`. Trigger it yourself to page EMS.
`qs:client:colorsChanged`	client (local)	`palette`	The player's colours changed: re-send them to your UI.
`qs:client:notify`	server → client	`message, type?, duration?, title?`	Shows a notification. Server: `TriggerClientEvent`; client: `TriggerEvent`.
`qs:client:revive`	server → client	—	Revives the player. Prefer `SetPlayerDead(source, false)` on the server.
`qs:client:forceDown`	server → client	—	Puts the player in the downed state. Prefer `SetPlayerDead(source, true)`.
`qs:metadata:set`	server → client	`key, value`	A metadata value changed.
`qs:money:add` / `qs:money:remove`	server → client	`account, amount, reason`	A balance changed.
`qs:money:set`	server → client	`account, amount`	A balance was set.
`hud:client:OnMoneyChange`	server → client	`account, amount, isMinus`	An extra account (not `cash` or `bank`) changed.

lua

AddEventHandler('qs:client:onPlayerLoaded', function(data)
    print(('Welcome back, %s %s'):format(data.charinfo.firstname, data.charinfo.lastname))
end)

AddEventHandler('qs:client:onJobUpdate', function(job)
    if job.name == 'police' then
        -- create your police blips here
    end
end)

Event	Side	Arguments	Use
`qs-inventory:usedItem`	server (local)	`source, item, slot, info`	Fired by `qs-coreinventory` after a useable item. qs-core re-fires it as `qs:server:usedItem`, which is the one to listen to.
`qs-inv:client:set`	server → client	`{ slots, columns, items, weight, maxWeight, secondary? }`	Full inventory snapshot after every change.
`qs-inv:client:equip`	server → client	`weapon, ammo`	A weapon item was used.
`qs-inv:client:itembox`	server → client	`{ name, label, image, count, type }`	Item added or removed (`type` = `add` / `remove`).
`qs-corehud:display`	client (local)	`state`	`false` hides the HUD and minimap, `true` shows them again.
`qs:chat:display`	client (local)	`state`	Hides or shows the chat.
`chat:addMessage`	client	`{ args = { author, text } }`	Standard chat API, handled by `qs-corechat`.
`chat:addSuggestion`	client	`name, help, params`	Adds a command hint (`name` with `/`). Also `chat:addSuggestions` and `chat:removeSuggestion`.
`qs-corechat:client:message`	server → client	`{ author?, text, type? }`	Chat line with a style: `player`, `system`, `me`, `do`, `ooc`, `b` or `pm`.
`loadingscreen:finish`	client (local)	—	Closes the loading screen.
`loadingscreen:done`	client (local)	—	The loading screen has closed.
`qs-intro:finished`	client (local)	—	The intro is done or skipped; character selection starts.
`qs:clothing:apply`	server → client	`skin`	Applies an appearance (sent by `SetSkin`).
`qs-clothing:client:open`	client	`{ disabled, defaultSection, strip }`	Opens the appearance editor; `disabled` lists sections to hide (`face`, `upper`, `lower`, `accessories`, `tattoos`).
`qs-clothing:creatorClosed`	client (local)	`skin, saved`	The character creator closed.
`vehiclekeys:client:SetOwner`	server → client	`plate`	Gives the player keys (same name as qb-vehiclekeys). Also `qs-corevehiclekeys:client:give` and `qs-corevehiclekeys:client:remove`.
`qs-police:client:alert`	server → client	`{ x, y, z }, label?`	Dispatch alert on a police client. Use the `Alert` export to reach every officer.
`qs-needs:consume`	server → client	`'eat'` or `'drink'`	Plays the eat or drink animation only (no hunger or thirst change).

State bag	Set by	Value
`Player(source).state.citizenid` / `LocalPlayer.state.citizenid`	qs-core	Loaded character id.
`Player(source).state.job`	qs-core	Current job table.
`Player(source).state.name`	qs-core	Player name.
`Player(source).state.dead`	qs-core	`true` while downed.
`Player(source).state.cuffed`	qs-police	`true` while cuffed.
`Entity(vehicle).state.fuel`	LegacyFuel bridge	Fuel level 0–100.

Event	Side	Arguments	When it fires
`esx:playerLoaded`	server / client	server `source, xPlayer, isNew` · client `PlayerData, isNew, skin`	A character loaded.
`esx:onPlayerLogout`	client	—	After logout.
`esx:setJob`	server / client	server `source, job, lastJob` · client `job, lastJob`	Job or duty changed.
`esx:setAccountMoney`	client	`{ name, money, label }`	A balance changed.
`esx:playerDropped`	server	`source, reason`	A player with a character disconnected.
`esx:onPlayerDeath` / `esx:onPlayerSpawn`	client	`{ victimCoords, killedByPlayer, deathCause }` / —	The player died / spawned again.
`QBCore:Server:PlayerLoaded`	server	`Player`	A character loaded.
`QBCore:Client:OnPlayerLoaded`	client	—	A character loaded.
`QBCore:Server:OnPlayerUnload`	server	`source`	A player disconnected.
`QBCore:Server:OnJobUpdate` / `QBCore:Client:OnJobUpdate`	server / client	`source, job` / `job`	Job changed.
`QBCore:Server:OnMoneyChange`	server	`source, account, amount, action, reason`	Money changed.
`QBCore:Client:OnGangUpdate`	client	`gang`	Gang changed.
`QBCore:Client:SetDuty`	client	`onDuty`	Duty changed.
`QBCore:Player:SetPlayerData`	client	`PlayerData`	Player data refreshed.

GetOfflinePlayerByCitizenId

RemoveGang

engine

if exports['qs-core']:Progress({ duration = 5000, label = 'Repairing', canCancel = true }) then ... end

Commands and Exports

Commands and Exports

Commands#

Keybinds#

Fixed controls#

qs-core server exports#

Players and characters#

Money and accounts#

Jobs, gangs and duty#

Metadata and skin#

Items and inventory#

Vehicles#

Permissions and groups#

Bans#

Callbacks and notifications#

Utilities#

qs-core client exports#

Other resources' exports#

Events#

Framework events (server)#

Framework events (client)#

Resource events#

ESX and QBCore events#