---
hide_title: false
hide_table_of_contents: false
pagination_next: null
pagination_prev: null
---

# `CacheOverride()`

The **`CacheOverride` constructor** lets you configure the caching behavior of a `Response`.

Normally, the HTTP Headers on a [`Response`](../../globals/Response/Response.mdx) would control how the [`Response`](../../globals/Response/Response.mdx) is cached,
but `CacheOverride` can be set on a [`Request`](../../globals/Request/Request.mdx), to define custom caching behavior.

## Syntax

```js
new CacheOverride(mode)
new CacheOverride(mode, init)
new CacheOverride(init)
```

> **Note:** `CacheOverride()` can only be constructed with `new`. Attempting to call it without `new` throws a [`TypeError`](../../globals/TypeError/TypeError.mdx).

### Parameters

- `mode` _: string_
  - Sets the cache override mode for a request
  - If set to:
    - `"none"`: Do not override the behavior specified in the origin response’s cache control headers.
    - `"pass"`: Do not cache the response to this request, regardless of the origin response’s headers.
    - `"override"`: Override particular cache control settings using the `CacheOverride` object's settings.
       This options is also the default when providing an init object directly as the first argument.

- `init`

  - : An Object which contains all the configuration options to apply to the newly created `CacheOverride`.

    - `pci` _: boolean_ _**optional**_
      - Override the caching behavior of this request to enable or disable PCI/HIPAA-compliant non-volatile caching.
      - By default, this is `false`, which means the request may not be PCI/HIPAA-compliant. Set it to `true` to enable compliant caching.
      - See the [Fastly PCI-Compliant Caching and Delivery documentation](https://docs.fastly.com/products/pci-compliant-caching-and-delivery) for details.

    - `surrogateKey` _: string_ _**optional**_
      - Override the caching behavior of this request to include the given surrogate key, provided as a header value.
      - See the [Fastly surrogate keys guide](https://docs.fastly.com/en/guides/purging-api-cache-with-surrogate-keys) for details.
    - `swr` _: number_ _**optional**_
      - Override the caching behavior of this request to use the given `stale-while-revalidate` time, in seconds
    - `staleWhileRevalidate` _: number_ _**optional**_
      - A synonym for `swr`.
    - `staleIfError` _: number_ _**optional**_
      - Override the caching behavior of this request to use the given `stale-if-error` time, in seconds

    - `ttl` _: number_ _**optional**_
      - Override the caching behavior of this request to use the given Time to Live (TTL), in seconds.
    
    - `beforeSend` _:Function_ _**optional**_
      - `(request: Request) => void | PromiseLike<void>`
      - Callback to be invoked if a request is going all the way to a backend, allowing the request to be modified beforehand.
      - See [Modifying a request as it is forwarded to a backend](https://www.fastly.com/documentation/guides/concepts/edge-state/cache/#modifying-a-request-as-it-is-forwarded-to-a-backend) in the Fastly cache interfaces documentation for details.

    - `afterSend` _: Function_ _**optional**_
      - `(response: Response) => void | CacheOptions | PromiseLike<void | CacheOptions>`
      - Callback to be invoked after a response has been sent, but before it is stored into the cache.
      - Where `CacheOptions` contains:
        - `cache` _: boolean | 'uncacheable'_ _**optional**_
          - Whether to cache this response. By default, leaving this field empty, responses will be cached based on their cache header information.
          - Setting this to true or false will override this default cache behaviour, setting in the cache or not setting in the cache, even if the default behaviour would have been otherwise.
          - Setting to 'uncacheable' the response will not only not be cached, but the cache will record that the originating request led to an uncacheable response, so that future cache lookups will result in immediately going to the backend, rather than attempting to coordinate concurrent requests to reduce backend traffic.
          - See the [Fastly request collapsing guide](https://www.fastly.com/documentation/guides/concepts/edge-state/cache/request-collapsing/) for more details on the mechanism that `uncacheable` disables.
        - `bodyTransformFn` _: Function_ _**optional**_
          - `(body: Uint8Array) => Uint8Array | PromiseLike<Uint8Array>`
          - Provide a function to be used for transforming the response body prior to caching.
          - Body transformations are performed by specifying a transform, rather than by directly working with the body during the onAfterSend callback function, because not every response contains a fresh body: 304 Not Modified responses, which are used to revalidate a stale cached response, are valuable precisely because they do not retransmit the body.
          - For any other response status, the backend response will contain a relevant body, and the `bodyTransformFn` will be applied to it. The original backend body is passed in to the transform function, and the function is expected to return the new body.
      - See [Controlling cache behavior based on backend response](https://www.fastly.com/documentation/guides/concepts/edge-state/cache/#controlling-cache-behavior-based-on-backend-response) in the Fastly cache interfaces documentation for details.

### Return value

A new `CacheOverride` object.

## Examples

In this example we override the cache for all the requests prefixed /static/ to have a long TTL (Time To Live),  and the home page to have a short TTL and a long SWR (Stale While Revalidate).

<Fiddle config={{
  "type": "javascript",
  "title": "CacheOverride Example",
  "origins": [
    "https://http-me.fastly.dev"
  ],
  "src": {
    "deps": "{\n  \"@fastly/js-compute\": \"^1.0.1\"\n}",
    "main": `
/// <reference types="@fastly/js-compute" />
import { CacheOverride } from "fastly:cache-override";
// In this example we override the cache for all the requests prefixed /static/ 
// to have a long TTL (Time To Live), and the home page to have a short TTL and 
// a long SWR (Stale While Revalidate).
async function app (event) {
  const path = (new URL(event.request.url)).pathname;
  let cacheOverride;
  if (path == '/') {
    cacheOverride = new CacheOverride('override', {ttl: 10, swr: 86_400});
  } else if (path.startsWith('/static/')) {
    cacheOverride = new CacheOverride('override', {ttl: 86_400});
  } else {
    cacheOverride = new CacheOverride('none')
  }
  return fetch(event.request.url, {
    cacheOverride,
    backend: 'origin_0'
  });
}
addEventListener("fetch", event => event.respondWith(app(event)));
`
  },
  "requests": [
    {
      "enableCluster": true,
      "enableShield": false,
      "enableWAF": false,
      "method": "GET",
      "path": "/status=200",
      "useFreshCache": false,
      "followRedirects": false,
      "tests": "",
      "delay": 0
    }
  ],
  "srcVersion": 1
}}>

```js
/// <reference types="@fastly/js-compute" />
import { CacheOverride } from "fastly:cache-override";
// In this example we override the cache for all the requests prefixed /static/ 
// to have a long TTL (Time To Live), and the home page to have a short TTL and 
// a long SWR (Stale While Revalidate).
async function app (event) {
  const path = (new URL(event.request.url)).pathname;
  let cacheOverride;
  if (path == '/') {
    cacheOverride = new CacheOverride('override', {ttl: 10, swr: 86_400});
  } else if (path.startsWith('/static/')) {
    cacheOverride = new CacheOverride('override', {ttl: 86_400});
  } else {
    cacheOverride = new CacheOverride('none')
  }
  return fetch(event.request.url, {
    cacheOverride,
    backend: 'origin_0'
  });
}
addEventListener("fetch", event => event.respondWith(app(event)));
```

</Fiddle>