Migrate from Oracle Content Management to Payload

If you are moving off Oracle Content Management, the move is often not optional — Oracle has wound the product down, and the work is to get onto a platform you control before the clock runs out. WAYF has done exactly this in production: we migrated Ingersoll Rand’s China platform off Oracle Content Management onto Payload on AWS, before the discontinuation deadline, with zero downtime at cutover. The mechanics below are drawn from that work.

WAYF is a Payload Partner agency and a top contributor to its open source. OCM is Oracle Content Management, also shipped under the Oracle Content and Experience name; the two refer to the same product here.

Field mapping

Each Oracle Content Management content type becomes a Payload collection, each field a Payload field. The table covers the OCM field set.

OCM field	Payload field	Notes
Text	text	Direct
Large text	textarea	Direct
Rich text	richText (Lexical)	Stored as HTML — convert, see below
Number	number	Integer
Decimal	number	Direct
Boolean	checkbox	Direct
Date	date	ISO in; check timezone handling
Media (digital asset)	upload	Migrate assets first; mind renditions
Reference (content item)	relationship	GUID-based — two-pass
JSON	json	Direct
Embedded content	blocks or group	Depends on whether the set is ordered/mixed
Any field, multi-valued	add hasMany: true	OCM allows most field types to repeat

The rows that carry the work are digital assets, references, and any embedded or multi-valued content.

Digital assets and renditions

Oracle Content Management separates content items from digital assets, and this is where the migration spends time. An item’s media field references a digital asset by GUID. Each digital asset holds a native file plus auto-generated renditions — derived sizes and formats produced by OCM’s asset pipeline.

Migrate the native, original file for each asset and let Payload regenerate sizes through its own image pipeline (imageSizes on the upload collection). Carrying OCM’s renditions across adds no value and ties the new platform to the old one’s naming. Build a guid → payloadMediaId map as you migrate assets, and resolve every item’s media reference through it.

Assets also carry metadata — tags, taxonomy categories, and custom attribute fields. Decide up front which of these the new model keeps, and map them onto fields on the Payload media collection so the asset library stays searchable after the move.

The repository and channel model

OCM organises content into repositories (where items and assets live) and publishes them to channels (delivery targets, each with its own published state). A single item can be published to several channels.

For the migration, settle two questions before writing code: which repository is the source of truth, and which channel’s published content you are migrating. Usually that is the production channel. Map the publish state onto Payload’s drafts through its versions feature, so an item that is not published to your chosen channel lands as a draft rather than going live on import. OCM taxonomies and collections become Payload relationships or a select field, depending on how the new model wants to use them.

How the migration runs

Export the content

Two routes:

• OCE Toolkit (cec CLI) downloads content items and assets from a repository or channel to a local structure. Good for a controlled, repeatable export.
• Content Management REST API when reading a live instance. Items carry a GUID id, a type, a fields object, and a language. Page through each type:

async function* readItems(type: string) {
  let offset = 0;
  for (;;) {
    const res = await fetch(
      `${OCM_URL}/content/management/api/v1.1/items` +
        `?q=(type eq "${type}")&limit=100&offset=${offset}&fields=all`,
      { headers: { Authorization: `Bearer ${OCM_TOKEN}` } },
    );
    const { items, hasMore } = await res.json();
    yield* items;
    if (!hasMore) break;
    offset += items.length;
  }
}

Migrate assets first

Pull each digital asset’s native file, create a Payload upload, and record the GUID map:

const buffer = Buffer.from(await (await fetch(asset.nativeFileUrl)).arrayBuffer());
const created = await payload.create({
  collection: "media",
  data: { alt: asset.fields?.altText ?? asset.name ?? "" },
  file: { data: buffer, name: asset.name, mimetype: asset.mimeType, size: buffer.byteLength },
});
assetIdMap.set(asset.id, created.id);

Import items, then resolve references

Pass one creates items with reference fields blank and records guid → payloadId, resolving media references through the asset map as it goes. Pass two updates each item, swapping referenced GUIDs for Payload IDs. Circular references between item types make a single ordered pass impossible, which is why the relationships wait for the second pass.

Rich text: HTML to Lexical

Oracle Content Management stores rich text as HTML. Run it through an HTML-to-Lexical importer: parse the HTML, walk the DOM, and emit Lexical nodes — headings, paragraphs, lists, quotes, links, and inline images. Inline <img> tags and asset links reference digital assets by GUID or URL, so resolve them through the asset map during the transform. Create one document by hand in the Payload admin and read its stored richText value to confirm the exact node shape your transformer must produce.

Localization

OCM holds translations as language variants of an item, linked through a translation set with a master language. Payload keeps locale variants under one document ID, selected by a locale argument on each write. Group an item’s language variants by their translation set, import the master language first to create the Payload document, then update the same document for each additional language. Map OCM’s language codes onto your Payload locale identifiers up front.

What it costs

A repository with a handful of content types, a moderate asset library, and a single language is three to five engineering days: schema derivation, the export, the asset pipeline, and a cutover rehearsal.

A large enterprise platform — many content types, tens of thousands of digital assets, deep references, HTML rich text with embedded media, multiple languages, and a hard discontinuation deadline — is a multi-week migration run by a coordinated team. We delivered exactly this for Ingersoll Rand: thousands of pages and tens of thousands of media assets and redirects, validated against the legacy build, live with zero downtime before the OCM deadline. A scoped discovery is the place to size yours.

If you are facing the Oracle Content Management discontinuation and want an honest read on what moving your platform involves, a 25-minute call is the fastest way to get one.