AI Transforms

Transform content at the edge, without touching your CMS

Rewrite, translate, shorten, or enrich JSON responses before they reach your app. Keep your CMS as the source of truth, cache transformed results at the edge, and serve the content shape each experience needs.

Start for Free — No Card Required Read AI Transform Docs
  • No CMS model changes
  • Server-side transformations
  • Edge-cached results
  • Edge content experiments

Origin response

Source of truth 

{
  "title": "Summer campaign",
  "description": "Long product
   copy from the CMS..."
}

AI Transform

Profile

rewrite · translate
shorten · enrich

Transformed responses

Delivery shapes

  • SEO metadatameta + descriptions
  • Mobile summaryshort copy
  • Localized copyper-market fields
  • Campaign varianttone + framing

Use cases

One source of truth. Many delivery shapes.

Keep editorial content clean in the CMS, then generate the response shape each frontend, market, or campaign needs at delivery time.

Localize campaign copy

Translate selected fields for markets without duplicating CMS entries.

Generate SEO fields

Create meta titles, descriptions, summaries, or product snippets from existing content.

Shorten for mobile

Return concise versions of long copy for small screens and performance-sensitive layouts.

Adapt tone by channel

Serve different copy for landing pages, ads, previews, or product experiences.

Clean legacy content

Normalize old descriptions, simplify formatting, or create consistent summaries.

Test content variants

Shape responses for experiments, campaigns, or audience-specific experiences.

Experiments

Test content variants from the edge

Create variants from the same CMS response, assign traffic at the delivery layer, and cache each transformed result separately. Your CMS stays clean, your frontend stays simple, and every request can expose the experiment, variant, and transform profile used.

CMS response

source of truth

Experiment rule

traffic split

Variants

A · B · …

Transform profiles

per-variant rewrite

Edge cache

scoped per variant

App

final shape

One source response

Start from the same CMS entry instead of creating duplicate experiment content.

Multiple transform profiles

Generate shorter, localized, SEO-focused, or campaign-specific variants from the same data.

Edge-level assignment

Route visitors to variants before the response reaches the frontend.

Cached per variant

Keep each transformed result fast with separate cache keys for each profile or variant.

Debuggable delivery

Expose experiment, variant, and transform headers so teams can verify what was served.

Frontend stays simple

Your app receives the final content shape instead of carrying experiment-specific transform logic.

Why transform at the edge?

Change the response shape, not the CMS model

Most teams eventually need content that differs from the editorial model: shorter copy, localized fields, SEO metadata, summaries, or campaign-specific variants. Putting that logic in every frontend creates drift. Duplicating entries in the CMS creates editorial overhead. Cachely keeps the CMS clean and transforms the response at the delivery layer.

Instead of changing the CMS model

Keep editorial schemas stable and avoid migration work for every new campaign or channel.

Instead of duplicating content

Generate delivery-specific fields from the same source entry.

Instead of frontend-only logic

Run transformations server-side once, cache the result, and serve it consistently.

How it works

From origin response to cached variant

Transform profiles run inside Cachely's delivery layer. Each profile produces its own cache key, so transformed responses stay just as fast as untransformed ones after the first request.

CMS Origin

source of truth

API Proxy

/~api/…

AI Transform

profile rewrite

Edge Cache

scoped key

Frontend

final shape

  1. 1Your app requests a CMS API response through Cachely.
  2. 2Cachely fetches the origin response or reads it from cache.
  3. 3A transform profile rewrites selected JSON fields server-side.
  4. 4The transformed response is cached at the edge with its own cache key.
  5. 5Your frontend receives the final content shape without extra client-side logic.

Transform profiles

Transform only the fields you choose

Define instructions per profile, preview the output, then serve transformed responses through the same edge delivery layer.

Profile instruction

product

For each product, create:

  • metaTitle under 60 characters
  • shortDescription under 160 characters
  • summary_fr translated for French buyers

Before

origin
{
  "title": "Linen Overshirt",
  "description": "A relaxed long-form product
   description with care notes, fabric origin,
   and editorial paragraphs from the CMS..."
}

After

cached at edge
{
  "metaTitle": "Lightweight Linen Overshirt",
  "shortDescription": "A breathable layer for warm days.",
  "summary_fr": "Une surchemise légère pour les journées chaudes."
}

For developers

Use transforms from the same API proxy

Transform profiles run inside Cachely's delivery layer. Your frontend keeps requesting content through the API proxy — set a default profile when you create the fetch, or scope it per request with .with({ transform }).

Default profile

Pass transform to createCachelyFetch() and every matching request uses that profile by default.

Per-request override

Call .with({ transform }) to derive a scoped fetch. The original fetch is never mutated — pass undefined for a clean no-transform scope.

Direct URL parameter

Cachely also accepts ?transform=<profile> on the proxy URL when you call it without the SDK.

Experiment & variant headers

Experiments can select transform profiles at the delivery layer. Inspect X-Cachely-Experiment-Id, X-Cachely-Variant-Id, and X-Cachely-Experiment-Profile on the response to verify the active experiment, variant, and profile.

TypeScript · @cachely-io/sdk 

import { createCachelyFetch } from '@cachely-io/sdk'

const cachelyFetch = createCachelyFetch({
  tenant: 'my-project',
  provider: 'prismic',
  transform: 'launch-campaign'
})

// Override the transform profile per request — original fetch is not mutated.
const mobileFetch = cachelyFetch.with({ transform: 'mobile-summary' })
const frenchFetch = cachelyFetch.with({ transform: 'french-market' })

// Or skip transformation entirely for a single call.
const rawFetch = cachelyFetch.with({ transform: undefined })

const response = await mobileFetch(
  'https://my-repo.cdn.prismic.io/api/v2/documents/search?ref=abc'
)

AI Transforms

Start transforming content at the edge

Keep your CMS clean, keep transformation logic out of the frontend, and cache the final response close to users.

Start for Free — No Card Required Read AI Transform Docs