Retool Classic App JSON import fails with "t.get is not a function" when adding queries or components to an existing app

I'm looking for guidance on a Retool Classic App JSON import problem. I'm not a software developer, but I'm using ChatGPT, OpenAI Codex, and Claude to help develop and maintain an operational application built in Retool.
The problem
I have an existing production Retool application called Operative Dashboard and a separate development/testing version called Operative β€” QA.
We've successfully built and tested new functionality in the QA app. The feature allows a user to select multiple games and assign a videographer to them, rather than assigning games individually.
We now need to transfer those additions into the production application without replacing the existing production configuration, resource connections, or unrelated functionality.
Our process has been:
Export the current production application as JSON.
Export the working QA application as JSON.
Have Codex identify the specific new components, queries, and configuration changes made in QA.
Create a modified copy of the production JSON that includes only those approved additions.
Test importing the modified JSON into a disposable Retool application before touching production.
The import fails with this error:
t.get is not a function
What we have already tested
We created a disposable application called ThrowawayTest to isolate the problem.
The following tests were performed:
Import test
Result
Original production JSON export
Successful
Complete QA JSON export
Successful
Production JSON with one additional query
Failed
Production JSON with a QA-bound query
Failed
Production JSON with an adjusted application compatibility flag and QA-bound query
Failed
Our testing indicates that both original exports are individually importable, but the modified production JSON fails when we add a new plugin/query definition.
We have also tested variations involving resource identifiers, application identifiers, page identifiers, and an application-level compatibility flag, without resolving the error.
We have stopped experimenting because we do not want to risk damaging the production application.
Environment and constraints
Retool Classic Apps
Retool Free plan
Production and QA applications are separate
Both applications use Supabase PostgreSQL resources, but connect to different database projects
The QA feature has already been tested successfully
We want to preserve the existing production application and its unrelated functionality
We understand that changes to our production application can become live immediately because release management is unavailable on our plan
My questions

  1. What does "t.get is not a function" typically indicate during a Retool Classic App JSON import?
    Is this associated with incompatible serialized component/query definitions, missing internal metadata, application version differences, or something else?
  2. Is manually combining portions of two exported Retool Classic App JSON files a supported operation?
    If not, is there an official or recommended method to transfer selected queries, components, modals, JavaScript handlers, and layout changes from one Classic App to another?
  3. Can we safely transfer these additions without replacing the entire production application?
    For example, is there a supported way to copy components and queries between applications, or use Retool's editor to reconstruct the feature while preserving existing application behavior?
  4. What is the best approach for transferring tested features from QA to production on a Free-plan Retool instance without a separate release-management workflow?
  5. Is there a supported way to inspect, validate, or repair a modified Retool JSON export before attempting an import?
    A request regarding your response
    I'm not a coder, so I would greatly appreciate a response that is technically specific but structured as step-by-step instructions I can pass directly to ChatGPT, Codex, or Claude.
    Ideally, please identify:
    The likely cause of the import error, clearly distinguishing confirmed facts from possibilities.
    The safest supported approach for transferring the QA functionality.
    Any Retool documentation, commands, or editor procedures that apply.
    What technical information or sanitized JSON examples you would need to diagnose the issue further.
    Any approach we should specifically avoid.
    If the recommendation involves modifying exported JSON, please describe the required structure or metadata precisely rather than suggesting trial-and-error changes.
    I can provide sanitized portions of the exports, the exact error details, and the differences between the working and failing versions if that would help.
    My priority is to preserve the working production application while promoting the successfully tested QA changes safely and reproducibly.
    Thank you for any assistance.

Summary

On Retool Classic Apps (self-serve cloud, no source control/release management), a workflow of hand-editing and merging two exported app JSON files (production + QA) to promote a tested feature fails on import with the error "t.get is not a function," even though each unmodified export imports successfully.

AI Response

The import fails because manually combining or editing portions of two exported Classic App JSON files is not a supported operation β€” the export is an internally consistent, serialized snapshot of one app, and inserting a query/plugin definition from another export breaks the internal references Retool expects on import, which surfaces as a generic deserialization error like "t.get is not a function." This is an editor-level operation, not a JSON-merging one: Retool does not provide an official schema for splicing exports together, so there is no reliable metadata to patch and trial-and-error edits should be avoided. Instead, open both apps in the Classic editor and use the native copy/paste support to move the new components (and queries) from QA directly into production β€” selecting components and pasting them into the production app preserves existing functionality rather than replacing it. A safe approach on a plan without release management is to first duplicate the production app, paste the QA additions into the duplicate to verify everything works, then reproduce the same paste into production; for the query/handler logic itself, copying queries between apps (or extracting shared logic into a module) avoids touching the raw JSON entirely.

Sources

:bookmark: Import and export classic apps | Retool Docs
Official Classic Apps import/export guide: exports cover whole apps (queries, components, modules β€” not resources) and are imported as complete apps, confirming that manually merging exported JSON is outside the supported import flow.
:bookmark: Transfer/copy and paste components between apps
Solved community thread confirming the supported way to move pieces between apps is native copy/paste in the editor, which is the safe alternative to hand-editing JSON for promoting the QA additions into production.

The Community Team is testing out a new automation. Let us know if it's helpful (or not) by leaving a :heart:, :+1:, or :-1:. Or by marking this post as the "Solution"! Let us know if you have any feedback here. :rocket:

I think it's the export format, not your IDs. Classic exports store the app as one transit-encoded string (all the ~#iR / ^1 / ^2 stuff), and those ^ references are numbered per file. Copy a query from the QA export into the prod one and its references point at the wrong keys, so the import chokes with t.get is not a function. That's why both untouched exports work and any merge breaks.

I'd stop merging JSON. Duplicate prod as a backup, copy/paste the new components from QA into prod in the editor, and recreate the queries by hand on the prod resource. Then double-check any event handlers that call queries by name.

One extra check for the rehearsal in the production duplicate: verify where every write query actually goes. Your QA and production apps use different Supabase projects; a separate app name doesn’t establish data isolation.

Use the test project and three dummy games: select the first and third, assign a test videographer, and verify that those two games got the assignment and the middle one didn’t. Then check the old single-game assignment too. If assignment sends notifications, use test recipients. This gives you an acceptance check for the transferred feature before repeating the editor changes in production.