Skip to content

Resource integration ​

Legitimate gameplay scripts can teleport players, change plates or create explosions. Authorize the specific action from a trusted server-side resource rather than disabling a whole detection.

Short server-side exemptions ​

The current resource provides these exports. playerId is the player's server ID and the duration is in milliseconds.

ExportAction
AllowTeleport(playerId, duration)Temporarily authorizes movement for a scripted teleport.
AllowPlateChange(playerId, duration)Temporarily authorizes a plate change.
AllowFreecam(playerId, duration)Temporarily authorizes a legitimate camera mode.
AllowVehicleProtection(playerId, duration)Temporarily authorizes a scripted repair or protection period.
AllowVehicleSpawn(playerId, duration)Temporarily authorizes a vehicle spawn.
AllowExplosion(playerId, duration)Temporarily authorizes a scripted explosion.
AllowProjectiles(playerId, duration)Temporarily authorizes a scripted rocket or laser effect from a trusted resource (1.8.32+).
AllowInvisible(playerId, duration)Temporarily authorizes invisibility.

The calling resource must be trusted for the corresponding detection in the effective server policy. Not every detection exposes a trusted-resource field in the dashboard. An export returning false means it did not grant the exemption; do not assume it succeeded.

For example, a repair resource configured under Vehicle godmode → Trusted resources can do:

lua
-- In the repair resource's SERVER script, before the repair:
local allowed = exports['VoidAC']:AllowVehicleProtection(playerId, 8000)
if not allowed then
    print('VoidAC: repair exemption was not authorized')
    return
end

-- Apply your validated repair here.

Validate who requested the action and whether they are entitled to it before calling an export. Do not expose an unrestricted network event that lets any client grant itself an exemption. Keep the duration as short as the action needs.

Anti vehicle: trusted spawns ​

Available from 1.8.14. Configure Anti vehicle → Trusted resources, integrate your garages and then enable the detection. Adding a resource name alone is not permission for arbitrary client spawns.

For client-created network vehicles, approve exactly one model from a validated server handler:

lua
-- In your trusted garage's SERVER code, after checking ownership/payment:
local permitted = exports['VoidAC']:AuthorizeVehicleSpawn(playerId, 'blista', 1500)
if not permitted then return end
-- Now tell only this player to perform that one validated spawn.

The permit is limited to that player, model, routing bucket and a maximum five-second lifetime. It is consumed once. Never create an unrestricted client event that calls this export. AllowVehicleSpawn remains a legacy vehicle-blacklist exemption; it does not bypass Anti vehicle.

For Spawn Safe, use a server-created vehicle instead:

lua
-- SERVER code of a listed resource, after validating the player's request:
local bucket = GetPlayerRoutingBucket(playerId)
local vehicle = exports['VoidAC']:CreateTrustedVehicle(
    'blista', 'automobile', 220.0, -800.0, 30.0, 90.0, bucket
)
if not vehicle then return end
-- Apply ownership/keys using your framework's server-side flow.

Spawn Safe enables OneSync's global relaxed entity lockdown unless a stricter mode is already configured. This also affects script-created peds and objects, not just vehicles. Client-side permits cannot override it, including for trusted resources. Convert affected scripts to server-side creation first. An existing routing-bucket lockdown override remains controlled by your own routing system.

Without Spawn Safe, Anti vehicle validates script-created network vehicles observed by the server. Client-local, non-networked objects are not observable by the server. Do not assume that this mode prevents every local visual entity.

Unauthorized vehicles are cancelled/deleted independently of report cooldowns. Block does not ban or kick the player. Warn also shows an in-game warning. The new detection defaults to disabled so an update does not silently break existing garage scripts.

Bridge for selected Lua resources ​

Open Preferences → Linked resources in the dashboard and enter your resource names, separated by commas. VoidAC adds server_script '@VoidAC/server/server.lua' to the selected manifests. In another resource, that file runs only its built-in bridge mode. It does not initialize another anticheat instance. Existing @VoidAC/bridge.lua references are migrated.

cfg
add_filesystem_permission VoidAC write adminmenu
add_filesystem_permission VoidAC write cardealer
ensure VoidAC
ensure adminmenu
ensure cardealer

Replace these example names with the resources you selected in the dashboard. The hosting runtime still requires filesystem permissions for manifest writes. VoidAC backs up manifests before adding the bridge and does not restart gameplay resources automatically. Restart the selected resources once after integration to load it. The legacy voidac_bridge_resources convar remains supported for migrating existing installations.

voidac_integrate in the server console reruns integration. Missing filesystem permissions are reported and the affected resources are skipped.

The bridge wraps Lua server natives. JavaScript and C# integrations should use the server exports. Client-only actions still need a validated server-side authorization path.

External manifest includes ​

From 1.8.32, standalone external references may be added to fxmanifest.lua, not just references to one particular anticheat:

lua
server_script '@AnotherResource/include/server.lua'
client_script '@AnotherResource/include/client.lua'
shared_script '@SharedLibrary/init.lua'

Keep every original line unchanged. These additions may appear at top level before, between or after original declarations. A reference must point to an external @resource/path; code statements, paths containing .., added tables/functions, duplicate extra references and edits to original metadata are rejected. Do not put declarations inside the existing server_scripts, files or other Lua blocks. Local unlisted code files are still rejected.

Official updates preserve allowed references and their relative placement where a matching original anchor remains. If an anchor disappears in the new version, the reference is kept at the end; review an integration whose load order matters.

External scripts are not signed or audited by VoidAC. Only reference resources you trust, keep their dependencies installed and test compatibility. A valid VoidAC file check does not establish that another resource's code is safe. This permission does not disable central key/IP checks or grant any player permissions.

The canonical original manifest is included in the signed release inventory. Do not edit voidac.integrity.json to approve changes: only the publisher can sign a valid replacement.

Weapon inventory checks (1.8.34+) ​

Weapon spawn compares the server-replicated equipped weapon with server inventory data. The adapter automatically checks ox_inventory, then QB or classic ESX inventory/loadout data. An unavailable or not-yet-loaded inventory is not treated as an empty inventory. Unsupported custom inventories need an explicit adapter before claiming this protection is active.

Repeated confirmed mismatches remove the weapon and apply the configured action. Damage with an unowned equipped weapon is blocked. Weapon switching and initial join synchronization have a short internal grace period. Vehicle weapon replication has limitations, so the periodic possession check does not punish players while seated in vehicles.

Explosion permits (1.8.34+) ​

Do not ban every explosionType == 7 event or infer cheating from an undocumented f104 field. Type 7 can be a normal destroyed vehicle. VoidAC validates event values, configured limits and explicit restrictions, and correlates destroyed vehicles where server state is available.

For a legitimate robbery or demolition script, list that server resource under Explosions → Trusted resources, validate the mission on the server, then authorize a bounded explosion:

lua
-- SERVER: after checking player, mission stage and location.
exports['VoidAC']:AuthorizeExplosion(playerId, {x = 100.0, y = 200.0, z = 30.0}, {
    types = {2}, radius = 5.0, count = 1, duration = 3000
})

The permit belongs to that player, location, radius and explosion type; it expires and is consumed once per approved explosion. Creating a client-callable event that grants unrestricted permits defeats this control. The existing AllowExplosion export remains a broader trusted-resource integration for older scripts.

Carry and drag scripts (1.8.34+) ​

Player protection prevents dragging a player out of a vehicle and detaches unapproved ped attachments. Add your legitimate carry/cuff resource to its trusted resources and call AllowPlayerAttachment(playerId, durationMs) on the server before starting the action. Maximum exemption duration is 30 seconds. Renew it only while the server verifies that the action remains legitimate. An attachment victim is never banned on the basis of a client-provided attacker ID.

One-use protected events (1.8.34+) ​

Do not change the payloads of every event globally. Existing frameworks require their original arguments, and identical payloads often represent valid repeated actions. Integrate the handler that owns a sensitive event instead:

lua
-- SERVER in the resource owning this event. Replace the validator and callback
-- with your actual authoritative mission/inventory/role checks.
exports['VoidAC']:RegisterSecureEvent('missions:claim', {
    OneUseToken = true,
    Arguments = {[1] = {Type = 'string', MaxLength = 64}},
    Validator = function(playerId, missionId)
        return YourMissionService.CanClaim(playerId, missionId)
    end
}, function(playerId, missionId)
    YourMissionService.ClaimOnce(playerId, missionId)
end)
lua
-- CLIENT in that same resource. Do not leave an unprotected duplicate handler.
exports['VoidAC']:TriggerSecureServerEvent('missions:claim', missionId)

The wrapper obtains a cryptographically random, player/event-bound token. It is consumed once and expires after ten seconds. Missing/reused tokens are rejected before the handler runs. The server validator is mandatory: a token does not prove that a player earned a reward. A fresh legitimate call with identical arguments remains valid. Anti trigger controls the response (Block, Log, Warn, Kick or Ban), not a blanket mutation of unrelated events. Disabling the detection does not remove application-level authorization from the registered handler.

Anti crash ​

Anti crash rejects malformed native event values and extreme particle scales/bursts. It does not promise to prevent every client crash or bugs in other resources. Start unfamiliar custom effects in a private test server and verify their normal event rates.

Keep keys private ​

Keep the downloaded voidac.key and the resource's validation flow intact. Do not move its API requests to a player's client, expose the key through events or copy another server's key. Normal configuration changes belong in the dashboard and survive updates.

VoidAC documentation