# QBCore vs Qbox: APIs, Compatibility and Migration Differences

Qbox began as a QBCore-derived framework, but `qbx_core` and `qb-core` are now distinct cores with
different native APIs, dependencies and resource architecture.

The important question is therefore not "which name is better?" It is whether your resources use
interfaces that are native to the target framework or covered by Qbox's QB compatibility bridge.

> This comparison is based on current project documentation and source. It does not claim that one
> framework is universally faster, safer or more production-ready. Test the exact revisions and
> integrations you plan to deploy.

![QBCore to Qbox script compatibility decision path](/diagrams/qbox.svg)

*Conceptual diagram; verify the behavior against your installed resource version.*

## QBCore vs Qbox at a glance

| Area | QBCore (`qb-core`) | Qbox (`qbx_core`) |
| --- | --- | --- |
| Core identity | QBCore's `qb-core` resource | Qbox's `qbx_core` resource |
| Primary API style | `QBCore` Core Object plus exports/events/functions | Export-oriented `qbx_core` APIs plus optional QB compatibility bridge |
| QBCore compatibility | Native | Qbox documents backward compatibility for most resources using supported QBCore interfaces |
| Core-object behavior | `exports['qb-core']:GetCoreObject()` returns the QBCore Core Object | Qbox has no native QBCore Core Object; its QB bridge can expose compatible `qb-core` behavior |
| Core dependency baseline | Current `qb-core` manifest declares `oxmysql` | Qbox currently documents `oxmysql`, `ox_lib` and `ox_inventory` as `qbx_core` dependencies |
| Resource ecosystem | Official/community `qb-*` resources and QBCore integrations | Native `qbx-*`/Qbox resources, Overextended integrations, plus bridged QB resources where compatible |
| Migration risk | Existing QBCore behavior is already native | Risk depends heavily on direct DB access, core-file access, custom patches and unsupported API usage |

Sources:
[QBCore Core Object](https://github.com/qbcore-framework/qb-docs/blob/main/qb-core/core-object.md),
[current `qb-core` manifest](https://github.com/qbcore-fivem/qb-core/blob/main/fxmanifest.lua),
[Qbox FAQ](https://docs.qbox.re/faq), and
[`qbx_core` README](https://github.com/Qbox-project/qbx_core).

## 1. Core architecture

### QBCore

QBCore resources commonly obtain the framework object with:

```lua
local QBCore = exports['qb-core']:GetCoreObject()
```

The Core Object exposes framework functions and shared structures used across the QBCore ecosystem.
QBCore's current documentation also supports filtered Core Object access so a resource does not need
to import every available table.

Read the local [Core Object reference](/docs/core/core-object) for the QBCore side.

### Qbox

Qbox's native core is `qbx_core`. Its project documentation describes an export-based API and a
different native architecture. Qbox explicitly states that it does **not** have the QBCore Core
Object.

When the QB bridge is enabled, compatibility code can still service common QBCore-style exports and
events. That bridge is an interoperability layer, not evidence that `qbx_core` and `qb-core` are the
same implementation.

Qbox documents the bridge convar as:

```cfg
setr qbx:enableBridge "true"
```

See the [Qbox convar reference](https://docs.qbox.re/resources/qbx_core/convars).

## 2. Will QBCore scripts work on Qbox?

Qbox's FAQ says most QBCore resources can work through its compatibility bridge **when they use
documented and proper QBCore interfaces**.

Qbox lists important exceptions, including resources that:

- access framework database tables directly,
- read or modify internal core files,
- use existing functions in unsupported ways,
- depend on implementation details that the bridge does not reproduce.

That means a marketing label such as "QBCore script" is not enough to predict Qbox compatibility.

### Compatibility review

Before moving a QBCore resource to Qbox, record:

1. every `qb-core` export it calls,
2. every QBCore event/callback it registers or triggers,
3. every direct SQL query against framework-owned tables,
4. every file imported directly from `qb-core`,
5. inventory, target, phone, banking, housing and garage dependencies,
6. any custom patch applied to the existing QBCore core.

Then compare those dependencies with the current Qbox bridge and native Qbox APIs.

## 3. Dependencies and ecosystem choices

Current `qb-core` declares `oxmysql` as a core dependency.

The current `qbx_core` README lists:

- `oxmysql`,
- `ox_lib`,
- `ox_inventory`.

This matters because a migration can be broader than swapping the core resource. Inventory,
interaction libraries and other ecosystem components may own persistent data or APIs used by your
custom resources.

Do not assume that a resource is migration-safe because it starts without an error.

If you replace resources instead of porting them, compare declared framework support and
dependencies on listings such as the [Qbox scripts on RPScripts](https://rpscripts.net/product-category/qbox-scripts/).
RPScripts and qbcore.net are operated by the same owner. A listing is not proof of compatibility.

## 4. Core Object vs native Qbox exports

For new QBCore code, use the documented QBCore interfaces for the QBCore version you deploy.

For native Qbox code, prefer the documented `qbx_core` exports rather than writing new code against a
legacy compatibility surface solely because existing QB resources use it.

This makes the integration boundary explicit:

- existing QBCore resource → bridge only if its used interfaces are covered,
- new Qbox-native resource → `qbx_core` APIs,
- new QBCore-native resource → QBCore APIs.

Qbox's documentation notes that converting a compatible resource to native Qbox APIs is not required
just to make the bridge work; conversion can still reduce dependency on the compatibility layer.

## 5. Migration from QBCore to Qbox

Treat migration as a data-and-integration project, not a framework rename.

### Inventory your current stack

Create a table for every resource:

| Resource | QBCore APIs used | Direct DB/core access | Inventory/target/UI dependency | Bridge status | Migration action |
| --- | --- | --- | --- | --- | --- |
| Example resource | Record exact exports/events | Yes/No | Record exact names | Verified/Unverified | Keep, adapt, replace or remove |

Do not fill the bridge-status column from assumptions. Verify it against current upstream
documentation/source or a staging test.

### Back up persistent state

Before changing framework or inventory behavior, back up:

- database,
- resource configuration,
- custom core/resource patches,
- item/job/gang definitions,
- migration scripts.

Document how you would roll back after players begin creating new state on the migrated server.

### Migrate on a copy

Run the migration against staging data first. Validate at minimum:

- character load and reconnect,
- money/accounts,
- inventory and metadata,
- jobs/gangs and grades,
- owned vehicles/property,
- permissions,
- resource callbacks/events,
- restart persistence.

Compare before/after record counts and sample ownership relationships where applicable.

### Remove assumptions one by one

A resource with direct QBCore database or file access should be treated as a migration task even if
the QB bridge covers its public exports.

Prefer an explicit adapter or native integration over two cores independently writing the same
state.

## 6. When staying on QBCore is the lower-change path

Staying on QBCore usually changes less when your current server:

- has substantial QBCore-specific custom code,
- patches `qb-core` or official `qb-*` resources,
- depends on integrations not verified against Qbox,
- has no current migration requirement that justifies data/integration work.

This is a change-scope observation, not a claim that QBCore is universally better.

## 7. When evaluating Qbox is reasonable

A Qbox evaluation is reasonable when you can:

- inventory every critical integration,
- verify bridge behavior for existing QB resources,
- adopt required Qbox/Overextended dependencies deliberately,
- migrate persistent data on staging,
- replace unsupported direct core/database access,
- prove rollback before production cutover.

This is not a recommendation to migrate solely for performance. Measure the actual bottleneck first.

## Performance claims

Do not use generic statements such as "Qbox is faster" or "QBCore is faster" as migration evidence.

Framework performance depends on:

- the exact core/resource revisions,
- resource count and behavior,
- database queries,
- NUI workload,
- loops/events,
- player load,
- server hardware and configuration.

Use FiveM profiling and equivalent staging scenarios when performance is the reason for considering a
migration.

See [QBCore performance guidance](/docs/performance).

## Related comparisons and migration guides

###

### All FiveM frameworks

    Compare QBCore, Qbox, ESX and other frameworks without turning pairwise migration details into a
    duplicate broad ranking page.

### QBCore vs ESX

    Review the architecture and migration boundary between QBCore and ESX.

### Migration planning

    Inventory integrations, persistent data, cutover checks and rollback before changing frameworks.

## Source notes

This page was reviewed on 27 September 2026 against current public QBCore and Qbox sources linked
above. Qbox compatibility statements are attributed to Qbox's own bridge/FAQ documentation and
should be rechecked against the exact Qbox revision you plan to deploy.

No synthetic benchmark, universal compatibility claim, or migration success rate is presented here.
