When Strapi content history is enough and when it is not
An editor who needs to undo a bad edit or compare two versions of a document can often do it without involving engineering, but only inside a fixed window. In the Strapi admin panel, Content History lets a user open an entry, review its earlier versions, compare them and restore a chosen version. It is available from the Growth plan. It covers document versions, not the whole database, so it does not bring back deleted content types, media files, configuration or a database state from another point in time. Start by treating it as an editorial undo tool, not as a disaster recovery mechanism.
The decision point is retention. On Growth, Content History keeps versions for 14 days. On Enterprise, retention can extend up to 90 days. If the editorial team's realistic need is to recover from mistakes noticed within two weeks, Growth may be enough. If errors are often found after a month, such as during a monthly review cycle or a slow approval process, the longer Enterprise window matters more than any feature difference. Confirm the exact retention setting for your plan and instance with Strapi before you rely on it, because the limit is what determines whether a restore is possible at all.
Content History is not enough when the restore must reach past the retention window, when the damaged content was deleted, or when the problem is in schema, configuration or media rather than in entry text. Check which of these your team could face. Also confirm how versions behave for relations, components, localized variants and media references, since a restored version may point to items that have changed since. Where the gap is not covered, your database backups must carry it, and those backups need their own retention, restore test and owner.
Before go-live, write a short restore policy that names who may restore content, which content types are in scope and what happens when the window has passed. Then run one restore on a staging copy and record the steps and the time it took. Ask your implementation partner to quote the staging test, the backup design and any Enterprise upgrade as separate line items, so you can compare them with the cost of the risk you are accepting.
Content history options by plan and need
This table compares Strapi's self-hosted plans for content history and version restore, with database backups as a separate safety net. Read the Community row first, because the supplied pricing information does not list content history among its self-hosted features. The main takeaway is that the retention window differs by plan, so teams with longer review or audit needs should plan backups that cover the gap.
| Plan or option | Availability and retention | Who can restore | Fit for the team |
|---|---|---|---|
| Community | Not listed among self-hosted features in Strapi's pricing information. Confirm before relying on it. | Confirm with Strapi for your version, then test in a staging instance. | Teams that can work without built-in version history and rely on backups and their own change records. |
| Growth | Included. Content history starts at the Growth plan. Retention is 14 days, so confirm the current window with Strapi. | Confirm which admin roles can restore in your version and set permissions to match. | Editorial teams that need recent version history and restore without Enterprise audit logs or review workflows. |
| Enterprise | Included, alongside audit logs and review workflows. Retention is up to 90 days, so confirm the exact setting for your contract. | Confirm role-based restore rights in your environment and document them for auditors. | Regulated or high-change teams that need the longest built-in window and fuller admin evidence. |
| Database backups (any plan) | Available through your own database tooling. Retention is set by your backup policy and should cover the gap beyond the built-in window. | Database administrators, under your change and approval process. | Teams that need restores older than the built-in window or a full environment recovery. |
How database backups cover what content history cannot
Content history keeps earlier versions of a Strapi document so editors can compare and restore them from the admin panel without involving an operator. For a mistake noticed quickly, such as an overwritten section found the same day, this is usually all the recovery the team needs. On the Growth plan, content history retains versions for 14 days. On Enterprise, the window extends to up to 90 days.
What is restored: one document version, selected in the admin panel and returned to the draft. Who runs it: the editor who made the change, or an administrator with the right permissions.
- The restore works on one document at a time and needs no database access or server access.
- No maintenance window is required, and other documents are not touched.
- The restored content becomes a new draft state that goes through the normal publishing path.
- Media files, configuration and changes outside the document history are not covered.
Confirm which retention period your plan provides and whether editors know that older versions expire.
When the error is discovered after the content history window has closed, the only remaining source of earlier content is a database backup. The team restores the database to a point before the change into a separate environment, locates the affected records and copies back only the content that needs recovery. The live database is not overwritten to do this.
What is restored: the whole database at the chosen backup point, then selected content extracted from it. Who runs it: the platform or database team, working with the content owner who identifies the correct version.
- A full restore brings back every change made after the backup point, so the team must plan how to merge or discard later edits.
- Restoring to a separate instance keeps the production system running while the team compares records.
- Document history in the restored copy may differ from what editors saw, so the content owner must validate the result.
- The restore procedure should be written down and rehearsed before an incident, not first attempted during one.
Confirm how often your database backups run, how long they are kept, and whether the retained points cover the time window your content owners may need.
A full environment failure, such as loss of the server, the database host or the storage volume, requires rebuilding the Strapi instance from backups. Content history is stored in the database, so restoring the database brings back the history records, but the application cannot work correctly without the matching media files and configuration. The recovery therefore covers both the database and the media store.
What is restored: the whole database, the media store and the deployment configuration needed to start Strapi. Who runs it: the platform or infrastructure team, with the application owner confirming the result.
- Media references in the database must match the files in the restored media store, or content will show broken assets.
- Secrets, environment variables and the Strapi version must match what the backup was taken from.
- The restored environment should be checked against known content and user counts before it is opened to editors.
- Restore procedures must be tested end to end on a non-production copy, including the time needed to bring Strapi back online.
Confirm that database and media backups are taken together or at points you can reconcile, and that a complete restore has been rehearsed in your own infrastructure.
Planning restores around retention windows and database backups
Start by deciding how far back you need to restore, and let that decision set the retention you buy or build. Map three inputs before you compare plans: business recovery requirements (how long a wrong edit, bad import or accidental deletion can go unnoticed before it matters), legal or audit holds (records that must keep their published state for a defined period), and editorial practice (how often editors revise high-risk pages such as pricing, policy or safety content). Then compare the result with the plan limits. Content History on the Growth plan keeps earlier versions for 14 days, and Enterprise extends that window up to 90 days. Confirm the exact window for your plan and version in Strapi's current documentation before you rely on it. Any requirement that exceeds the window needs a second mechanism, usually database backups or exported snapshots held under your own retention policy.
A restore of an earlier document version is a content operation. An editor opens the entry, chooses an earlier version, and brings it back as the working draft. Other documents, other editors' changes and the schema stay as they are, so the operation is narrow and reversible in the same workflow. A database restore is a different kind of action. It returns the whole database to the backup point and removes every write made after that point, including other editors' drafts, uploads metadata, localized variants, review or release changes, and admin or permission edits. Treat it as an incident response step with a named approver, a communication plan for editors and a clear statement of what content will be lost. Your backup frequency sets the maximum amount of work that can be lost, so match it to the recovery requirement you documented.
Database backups also have a fixed place in any Strapi 5 upgrade. Strapi's v4 to v5 migration guidance includes an upgrade tool with codemods, data migration scripts that run on the first start of Strapi 5, and a breaking changes list. The same guidance says to back up the database before you start, because downgrading is not supported. Once the migration scripts have run, the only rollback path for the data is the backup taken before them, so a backup that has never been restored is not a safety measure. Take the backup immediately before the migration window, record its time, and confirm that your database engine is on the supported list in the installation requirements. For Strapi 5, that list includes PostgreSQL 14 or later, MySQL 8.0 or later, MariaDB 10.3 or later and SQLite 3.
Turn these points into a short checklist before the first production restore question arrives. Confirm the Content History window for your plan and Strapi version. Write down the retention you need for each content type that carries legal, financial or safety weight, and decide whether database backups or an export process will cover the difference. Set the backup schedule from the maximum acceptable data loss, and keep a copy outside the primary database host. Run a restore into a separate staging instance at least once, time it, and check that media files, locales and permissions come back consistently with the database. Name who may approve a database restore and who tells editors when one happens. Ask your implementation partner or Strapi's sales team to confirm any retention figure that is not in the current pricing or documentation before you write it into policy.
How to set up and verify content history
This sequence confirms that your plan, Strapi version and database support content history, then proves that comparison and restore work on a non-production copy before anyone depends on them. The output is a written retention and restore procedure that your team can follow during an incident.
Confirm plan and edition in the admin panel
Sign in to the admin panel of a non-production instance as a super admin and find where the installation shows its plan or edition. Content history starts at the Growth plan in Strapi's self-hosted pricing, so a Community installation will not include it. Confirm the exact labels and locations in the current Strapi docs, because admin panel labels change between releases. You are done when you can state in writing whether the installation is on Growth or Enterprise.
Confirm the Strapi version and database
Check that the project runs Strapi 5 and record the exact version from the project's package manifest and lockfile. Confirm that the database is PostgreSQL 14 or later, MySQL 8.0 or later, MariaDB 10.3 or later, or SQLite 3, and that Node.js is an Active or Maintenance LTS version. Strapi 5 does not support MongoDB or other NoSQL databases. You are done when the Strapi version, database engine and Node.js version are recorded together and each matches the supported list in the installation requirements.
Create a non-production copy of the instance
Your platform or DevOps team copies the production database and uploaded media into an isolated environment and starts a Strapi instance against that copy. Keep the copy's admin accounts and API tokens separate from production. Compare a sample of content types and entry counts between production and the copy to confirm they match. You are done when the copy starts cleanly and a sampled entry shows the same fields and values as production.
Enable and test content history on the copy
Turn on content history for the test instance using the settings the current docs describe for your plan, and confirm the exact label before you change anything. Create a test document, save it at least three times with different values in a text field, then publish one version. Note whether edits made before the feature was enabled appear in the history, and record the answer. You are done when each save and publish creates an entry you can open.
Compare two versions of a test document
Open the history of the test document and select two versions from step four. Use the comparison view to list the field-level differences between them. Check that every change you made appears in the comparison, and that unchanged fields show no difference. If the content type includes relations or media, test those fields too, because they are easy to overlook. You are done when the comparison output matches the edits you recorded.
Restore a test document to an earlier version
Restore an earlier version of the test document using a user account with the role your editors would use, and confirm that the role can view and restore history. Check whether the restore writes to the draft, the published version or both, and confirm the result in the admin panel. Then query the public API for the published entry and check that it returns what you expect. You are done when the restored draft and the published API response both match the version you chose.
Determine retention and backup coverage
Confirm the retention window for your plan in the current docs and in your contract. The topic reference for this page lists 14 days on Growth and up to 90 days on Enterprise, so verify that figure for your installation before you rely on it. Work out which versions your restore needs fall outside that window and must come from a database backup. Ask your backup owner how long a restore from backup takes in your environment. You are done when you have a written table of retention windows, backup frequency and restore time.
Write the retention and restore procedure
Write a short runbook that names who may request a restore, who approves it, the steps in the admin panel (using the labels you confirmed), how to verify the result through the admin panel and the API, and when to switch to a database backup. Include where the history and backup records are kept. Ask a second team member to follow the runbook on the test document. You are done when that person reaches the same result without help.
Access, data handling and audit considerations for restores
Restoring an older version touches four controls: who holds the permission, how the restored draft moves through publishing, what the audit trail records, and how long stored versions survive. Each card sets out one of these decisions and the check to run before rollout. Treat version history as a copy of the source content, not as a lower-risk store.
Limiting restore to named roles
Decide which admin roles may open Content History and restore a previous version. Restoring overwrites the working copy, so treat it as an edit to live content and grant it only to editors who own that content type. In the admin panel, confirm that the standard content editing permissions do not include restore by default. Test with a non-administrator account on a staging instance before rollout, and record the role and permission set you approved.
Restores against publishing state
Confirm whether a restore changes published content or only the draft, and how the publish action then behaves. Where Review Workflows are in use, which is an Enterprise feature, check whether a restored draft must pass the review stages again before publication. Walk one document through restore, review and publish on staging, and record which role performed each step. Use that record as the approval evidence for your editorial process.
Recording restores in audit logs
Audit logs are an Enterprise feature, so on Growth or Community a restore has no admin-action record in Strapi. On Enterprise, confirm that restore actions appear in the audit log and that each entry identifies the user, the document and the time. Ask the vendor which fields are captured for a restore, then export a sample and check that it is enough to reconstruct what changed. Record how long entries are kept before export.
Version history holds sensitive content
Each saved version records the content as it stood at that point, so a field removed from the live entry may still exist in history. Apply the same retention period, access controls and deletion rules to version history as to the source content, including personal data that editors have since removed. List the content types that hold personal or regulated data, and set the retention window for each: 14 days on Growth, or up to 90 days on Enterprise.
Confirming how versions are purged
Ask the vendor how deleted document versions are purged: whether removal is immediate, whether it covers every stored version of a document, and whether it reaches replicas, exports and backups. A version removed in the admin panel may still exist in a database backup taken inside the retention window. Get the answer in writing, test it on a non-production document, and record it in your data handling register with the backup retention you set.
Testing restores before an incident
A restore drill is the only reliable way to learn whether Content History and your database backups can bring back the content you need. Run it on a schedule, not only after something goes wrong. Start by choosing a small sample of documents across the content types that matter most, including at least one type with relations, components, and localized fields if you use them. Record the current field values and the published state of each document before you change anything. Next, edit each sample document in the admin panel and save the changes. Then restore an earlier version of each document through Content History and confirm that the restored draft matches the values you recorded. Content History restores one document's version. It does not roll back other documents, schema changes, or configuration, so the drill should check that those untouched items still look as expected afterward.
The second half of the drill tests the database backup. Restore the most recent backup into a separate environment, never the production database, and point a Strapi instance at it with the same major Strapi version and plugin configuration as production. Compare the restored data with production for the sample documents: field values, relations, publication status, and API responses for the same requests. Check that media references resolve, since uploaded files are often stored outside the database and need their own restore path. Confirm where your files live with your upload provider before the drill. Define success in writing before the drill starts. A typical pass means every sampled document matches its expected values, every API request returns the same structure, and the restore finishes within the recovery window your team has agreed. Record the date, the backup identifier, the people involved, and every difference found. Those records are also the evidence a compliance reviewer or auditor will ask to see.
Testing restores also verifies the backup itself, and this is the part teams most often skip. A backup job that reports success only proves that a file was written. It does not prove the file can be read, that it contains the expected tables, or that it restores on the same database engine and version that production uses. Strapi 5 supports PostgreSQL 14 or later, MySQL 8.0 or later, MariaDB 10.3 or later, and SQLite 3, so the drill should use the same engine and version as production, not a convenient substitute. The frequency of the drill belongs in your organization's backup and continuity policy, and that policy should set it. Ask the policy owner how often drills must run, who approves the results, and what happens when a drill fails. Also run an extra drill after major upgrades, schema changes, or changes to the database or storage setup, because those are the changes most likely to break a restore.
Before the first drill, decide several operational questions. Name one owner for the drill and one backup approver. Decide where the separate restore environment lives, and make sure it is isolated from production systems and their credentials. If the backup contains personal data, confirm with your privacy or legal team that copying it into a non-production environment is permitted and that the environment has matching access controls. Ask your implementation partner or internal team to document the exact steps so that someone else can repeat the drill during an incident when the usual owner is unavailable. When you request a quote for this work, ask what the drill includes: scripted restore steps, comparison checks, evidence records, and support for failed runs. Confirm whether the Content History retention on your plan covers the recovery window you need, and whether database backups must cover any longer period. Those answers determine how much of the drill depends on Content History and how much depends on backups.
Limits to confirm in your environment before you rely on it
Content history is only as useful as the limits your plan and configuration set. The questions below cover the points that most often differ from editors' expectations, and each can be answered by Strapi or checked in a test environment before you depend on restores in production.
Retention window on your plan
Ask Strapi in writing how many days of versions the plan you buy keeps. The topic's comparison puts Growth at 14 days and Enterprise at up to 90 days, but the exact window on your contract should be confirmed before you plan around it. Ask whether the window is the same for every content type and whether it can be changed. Record the answer with your order so it is part of the agreed baseline.
Where the retention clock starts
Ask whether the window counts from the moment an editor saved a change or from the moment Strapi created the version record. For documents saved many times in one day, the difference decides which versions survive at the edge of the window. Test it by saving a document on a known date, then checking which versions remain as the window closes. Write down the result, because restore requests from editors will depend on it.
Versions for localized content
Ask how versions behave when a document has localized fields. Confirm whether each locale keeps its own history, whether a change in one locale creates a version for the others, and whether restoring one locale also restores shared, non-localized fields. Build a test content type with both kinds of field, edit two locales, and compare the version list and the restored result against what editors expect.
Versions after a schema change
Check what happens to existing versions when a content type's fields are renamed, removed or changed in type. Ask whether old versions keep the original field structure, whether they can be restored into the updated schema, and whether data in removed fields is lost. Run this on a copy of production content before any schema change ships, and include it in your upgrade test plan.
Version history in exports and transfers
Confirm whether version history is included in exports, database backups or transfers between Strapi environments. Content transfer is a separate process from the admin history view, so do not assume a staging copy carries version records with it. Ask the vendor directly, then run a transfer into a non-production instance and check the version list on the target before you rely on that path for recovery.
What teams ask before hiring help with content history
How much effort do setup and restore testing take for Strapi content history?
The effort depends on your plan, how many content types need version history, your backup architecture and your audit needs. Setup itself is a short configuration task on a supported plan. Most of the time goes into deciding which content types and fields matter for recovery, proving a restore on a non-production instance, and writing the steps your editors and operators will follow. Ask for the number of content types in scope, the number of environments to test, and whether restore testing covers only Strapi content or also the database backup path. A fixed-scope quote should list each of these as a line item so you can see what changes if the scope grows.
Which Strapi plan includes content history, and what does it cost?
Content history starts at the Growth plan on Strapi's self-hosted plans, according to Strapi's self-hosted pricing page. That page lists Growth at 45 US dollars per month including 3 users, plus 15 US dollars for each extra user. Enterprise is priced on request and adds audit logs and review workflows. Community, the free plan, does not include content history. Confirm current prices on the pricing page before budgeting, because list prices change. Your total cost also includes hosting, the database, storage and the hours for setup and testing, which are quoted separately from the license.
Can our own engineers configure Strapi content history without outside help?
Yes, a team with Strapi administration experience and access to a staging instance can enable and configure content history alone. Outside help is most useful when the team needs a restore procedure tested against its real database backup schedule, when content types are complex, or when the work must be documented for auditors. Before deciding, check whether your staff have time to run a restore test end to end, record the results and repeat the test after upgrades. Strapi upgrades, such as moving between major versions, change the data layer, so a restore procedure written for one version needs review after each upgrade.
What access and records do we need to provide before restore testing?
Start with access to a non-production Strapi instance that matches production as closely as possible. Provide the Strapi version, your plan details, the database engine and version, and the Node.js version in use. Strapi 5 supports PostgreSQL 14 or later, MySQL 8.0 or later, MariaDB 10.3 or later and SQLite 3, and it does not support MongoDB. It runs only on Active or Maintenance LTS Node.js versions. Also provide your current backup records, including schedule, retention, last successful restore test and where backups are stored. Confirm with your team which content types and locales are live, since these shape the test plan.
Does Strapi content history replace database backups?
No, content history does not replace database backups. Content history lets editors compare and restore earlier versions of a document within the plan's retention window. A database backup protects against losses that version history cannot reach, such as a failed upgrade, corrupted data, deleted records outside the retention window or a full environment failure. Strapi's v4 to v5 migration documentation tells teams to back up the database before upgrading because downgrading is not supported. Keep both: content history for editorial recovery, and tested backups for disaster recovery. Your restore test should show both paths working.
How long does Strapi keep content history versions on each plan?
Growth keeps content history for 14 days, and Enterprise keeps it for up to 90 days. Use these figures as planning inputs and confirm the current retention on Strapi's pricing or product documentation before you commit to a recovery policy. Anything older than the retention window must be recovered from a database backup, so your backup retention should be set with the content history window in mind. If your editorial or legal requirements call for longer recovery periods, write that requirement into the scope so the design includes backup retention and restore steps for it.
What should we verify about what content history can restore?
Test the behavior on a staging instance rather than relying on assumptions. Check which content types, components, relations, localized entries and media references restore cleanly, and note anything that needs a follow-up step. Confirm how restored versions interact with draft and published states, and whether editors need training on the restore action. Record the test steps, the expected result and the actual result. Repeat the test after each Strapi upgrade, plugin change or schema change, because these can alter how versions are stored and displayed.
How DeployOpen works on this
DeployOpen approaches Strapi content history and version restore as a scoped piece of work inside your own Strapi project and infrastructure. We confirm which plan and retention window fit your editorial needs, define how restores are tested, and document the backup procedure that covers anything older than the retention window. Engagements are fixed-scope, with a written scope agreed before work starts.
How we scope
- Confirm the Strapi plan and content types in scope, since content history starts at the Growth plan.
- State the retention window for your plan: 14 days on Growth, up to 90 on Enterprise.
- Agree in writing which content types, locales and editor roles the restore workflow covers before work starts.
How we build
- Configure content history on the agreed content types and confirm each document version is captured.
- Test comparing and restoring earlier versions with editors on a staging instance before production rollout.
- Build a database backup and restore procedure for recovery needs beyond the content history window.
How we hand over
- Document how editors compare and restore versions, with screenshots from your own instance and role settings.
- Provide the backup runbook, restore steps and owners for each recovery scenario.
- Walk through the handover with your editors, administrators and whoever runs database operations.
How we support
- Re-test content history after planned Strapi 5 minor upgrades in your environment.
- Review retention settings and backup schedules when your plan, editorial volume or recovery requirements change.
- Offer ongoing support and upgrades as a retainer, with the scope of each request agreed in writing.

