# Gemini Explicit Caching

Gemini explicit caching lets you reuse large blocks of context that must be sent repeatedly, such as product manuals, knowledge bases, fixed system rules, images, audio, or video. You first create the shared context as a cache; subsequent requests only send the `cache_id` and the new question for that request, which reduces repeated transmission and repeated processing.

A cache stores the following items from the creation request as a whole:

- `systemInstruction`: optional fixed role and answering rules.
- `contents`: the text or media material to be reused.

New questions sent later are not automatically appended to the original cache. Cache content cannot be modified after creation; currently, only extending the validity period is supported.

The examples in this document use `gemini-2.5-flash`. Gemini explicit caching currently supports only the following models:

| Model ID | Minimum cache tokens |
| --- | ---: |
| `gemini-2.5-flash` | 2,048 |
| `gemini-3.5-flash-lite` | 4,096 |
| `gemini-3.5-flash` | 4,096 |
| `gemini-3.6-flash` | 4,096 |
| `gemini-3.1-pro-preview` | 4,096 |
| `gemini-3-flash-preview` | 4,096 |

You must specify the same model when creating a cache and when using it. Other Gemini models cannot be used to create explicit caches unless they are listed in the table above, even if they can generate content normally.

> Explicit caching incurs a creation input charge and a storage charge. There is currently no API for manual deletion, so set the validity period according to your actual usage. The final expiration time after creation or update cannot be more than 7 days from the time of that request.

## Quick Start

### Prepare the API Key

The examples in this document use the following environment variables:

```bash
export MODELVERSE_API_KEY="<your_api_key>"
export MODELVERSE_BASE_URL="https://api.modelverse.cn"
```

All APIs use the following authentication header:

```text
Authorization: Bearer $MODELVERSE_API_KEY
```

Caches are isolated by API Key. You must use the API Key that created the cache when creating, querying, updating, and using the same cache.

### API Overview

| Operation | Method and path | Description |
| --- | --- | --- |
| Create cache | `POST /v1beta/cachedContents` | Caches fixed rules, text, and media, and returns a `cache_id`. |
| Use cache | `POST /v1beta/models/{model}:generateContent` | References the cache for synchronous generation. |
| Use cache with streaming | `POST /v1beta/models/{model}:streamGenerateContent` | References the cache for streaming generation. |
| Query caches | `GET /v1beta/cachedContents` | Queries the caches that are still valid under the current API Key. |
| Extend validity | `PATCH /v1beta/cachedContents/{cache_id}` | Extends the validity period only; does not modify the cache content. |

### Step 1: Create a Cache

Call `POST /v1beta/cachedContents` to write the fixed system rules and the material to be reused into the cache:

```bash
curl -X POST "$MODELVERSE_BASE_URL/v1beta/cachedContents" \
  -H "Authorization: Bearer $MODELVERSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-2.5-flash",
    "displayName": "product-manual",
    "ttl": "3600s",
    "systemInstruction": {
      "parts": [
        {
          "text": "You are a product support assistant. Answer based on the cached material first; when the material does not contain the answer, say so explicitly and do not guess."
        }
      ]
    },
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Put the complete product manual, FAQs, and handling procedures that need to be reused here..."
          }
        ]
      }
    ]
  }'
```

The elided content in the example must be replaced with real long context. `gemini-2.5-flash` requires at least 2,048 tokens, and the five currently supported Gemini 3 series models require at least 4,096 tokens. Creation fails if the content is too short.

On success, a ModelVerse cache ID is returned:

```json
{
  "cache_id": "cache_abc123",
  "model": "gemini-2.5-flash",
  "display_name": "product-manual",
  "status": "active",
  "created_at": "2026-07-24T02:00:00Z",
  "updated_at": "2026-07-24T02:00:00Z",
  "expire_time": "2026-07-24T03:00:00Z",
  "total_token_count": 11426
}
```

Save the `cache_id`. Subsequent APIs use only this ID; do not pass Google's `projects/.../cachedContents/...` resource name.

### Step 2: Use the Cache

After creating the cache, call the `generateContent` API of the same model and send only `cachedContent` and the new question:

```bash
curl -X POST \
  "$MODELVERSE_BASE_URL/v1beta/models/gemini-2.5-flash:generateContent" \
  -H "Authorization: Bearer $MODELVERSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "cachedContent": "cache_abc123",
    "contents": [
      {
        "role": "user",
        "parts": [
          {
            "text": "Please summarize the main features based on the cached product manual."
          }
        ]
      }
    ]
  }'
```

The `systemInstruction` and `contents` in the cache both take effect and do not need to be sent again. The streaming API `:streamGenerateContent` supports the same `cachedContent` usage.

### Step 3: Confirm a Cache Hit

When the cache is hit, `usageMetadata` in the Gemini response contains `cachedContentTokenCount`:

```json
{
  "usageMetadata": {
    "promptTokenCount": 11436,
    "cachedContentTokenCount": 11426,
    "candidatesTokenCount": 128,
    "totalTokenCount": 11564
  }
}
```

`cachedContentTokenCount` indicates the number of cached tokens reused by this request.

## Creating a Cache

**API**

```text
POST /v1beta/cachedContents
```

### Request Fields

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `model` | string | Yes | ID of a model that supports explicit caching: `gemini-2.5-flash`, `gemini-3.5-flash-lite`, `gemini-3.5-flash`, `gemini-3.6-flash`, `gemini-3.1-pro-preview`, or `gemini-3-flash-preview`. |
| `contents` | array | No | The actual material to cache; supports `text` and `inlineData` parts. |
| `systemInstruction` | object | No | The fixed role and answering rules to cache together; supports `text` parts only. |
| `displayName` | string | No | A display name that makes the cache easier to identify. |
| `ttl` | string or object | No | Relative validity period. A string such as `"3600s"` is recommended. Minimum 60 seconds, maximum 7 days (604,800 seconds). |
| `expire_time` | string | No | Absolute expiration time in RFC 3339 format; must be at least 60 seconds later than the current time and no more than 7 days from now. |

`contents` and `systemInstruction` must contain at least one non-empty part between them. They are stored as a single cache, not as two separate caches.

Only one of `ttl` and `expire_time` may be provided. If neither is provided, Google expires the cache 60 minutes after creation by default; the exact time is given by `expire_time` in the response.

Whether you use `ttl` or `expire_time`, the final expiration time after creation cannot be more than 7 days from the time of the request.

A string is recommended for `ttl`:

```json
{
  "ttl": "3600s"
}
```

An object with seconds and nanoseconds is also supported:

```json
{
  "ttl": {
    "seconds": "3600",
    "nanos": "0"
  }
}
```

When using an absolute time:

```json
{
  "expire_time": "2026-07-24T10:00:00Z"
}
```

### Difference Between `systemInstruction` and `contents`

`systemInstruction` defines fixed rules, such as the role, answering language, output format, and prohibitions; `contents` stores the actual material to be referenced repeatedly.

```json
{
  "systemInstruction": {
    "parts": [
      {
        "text": "Answer in English only, and output strictly in three sections: Conclusion, Evidence, and Recommendation."
      }
    ]
  },
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "This is the business material that needs to be queried repeatedly..."
        }
      ]
    }
  ]
}
```

Both parts count toward the cached tokens and both take effect when the cache is referenced. If you have no fixed rules, you may omit `systemInstruction`.

### Creation Response Fields

| Field | Description |
| --- | --- |
| `cache_id` | The ModelVerse cache ID; pass this value when using or updating the cache. |
| `model` | The ModelVerse model ID used to create the cache. |
| `display_name` | The display name provided in the request; not returned if not provided. |
| `status` | Cache status; `active` when creation succeeds. |
| `created_at` | Cache creation time. |
| `updated_at` | Time of the most recent update. |
| `expire_time` | The expiration time actually in effect upstream. |
| `total_token_count` | Number of tokens in the entire cache, including `systemInstruction` and `contents`. |

## Using the Cache

**Synchronous API**

```text
POST /v1beta/models/{model}:generateContent
```

**Streaming API**

```text
POST /v1beta/models/{model}:streamGenerateContent
```

The following conditions must be met when using a cache:

- Use the same API Key that created the cache.
- The model in the URL must match the `model` used when the cache was created.
- The cache must still be within its validity period.
- `cachedContent` must be the `cache_id` returned by ModelVerse.
- Do not pass `systemInstruction`, `tools`, or `toolConfig` again in the request.

You can still pass `generationConfig`, `safetySettings`, and the `contents` specific to this request.

New questions or new media in this request are not written back into the original cache. If this content also needs to be reused in subsequent requests, you must create a new cache.

### Adding a New Image While Using a Cache

The current question can carry a new, uncached image:

```json
{
  "cachedContent": "cache_abc123",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Please compare this latest screenshot with the older screenshot in the cache."
        },
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "<NEW_IMAGE_BASE64>",
            "displayName": "latest-console.png"
          }
        }
      ]
    }
  ]
}
```

## Querying the Cache List

**API**

```text
GET /v1beta/cachedContents
```

**Request**

```bash
curl "$MODELVERSE_BASE_URL/v1beta/cachedContents" \
  -H "Authorization: Bearer $MODELVERSE_API_KEY"
```

**Response**

```json
{
  "cachedContents": [
    {
      "cache_id": "cache_abc123",
      "model": "gemini-2.5-flash",
      "status": "active",
      "display_name": "product-manual",
      "createTime": "2026-07-24T02:00:00Z",
      "updateTime": "2026-07-24T02:00:00Z",
      "expireTime": "2026-07-24T03:00:00Z",
      "total_token_count": 11426
    }
  ]
}
```

The List API behaves as follows:

- It returns only caches created by the current API Key; other API Keys under the same company cannot see them either.
- It returns only caches that have not expired and whose status is `active`.
- It returns only the latest successful state for each `cache_id`.
- Results are sorted by creation time, newest first.
- It returns `{"cachedContents":[]}` when there is no valid cache.

> The time fields in the creation and update responses are `created_at`, `updated_at`, and `expire_time`; the List response follows the Gemini list structure, where the time fields are `createTime`, `updateTime`, and `expireTime`.

## Extending the Cache Validity Period

**API**

```text
PATCH /v1beta/cachedContents/{cache_id}
```

The cache content and model cannot be modified; an update request can only extend the validity period. The request body must contain exactly one of `ttl` or `expire_time`. The final expiration time after the update cannot be more than 7 days from the time of the request.

### Extending with a Relative TTL

```bash
curl -X PATCH \
  "$MODELVERSE_BASE_URL/v1beta/cachedContents/cache_abc123" \
  -H "Authorization: Bearer $MODELVERSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "ttl": "600s"
  }'
```

In the ModelVerse update API, `ttl` means "how much longer to extend beyond the current expiration time".

For example:

- Current expiration time: `10:30:00Z`
- Request: `{"ttl":"600s"}`
- New expiration time: `10:40:00Z`

It is not recalculated from the time the update request is sent.

Because `ttl` is added to the current expiration time, the maximum extension you can specify depends on the remaining validity period of the cache. For example, if 1 hour remains, you can extend it by at most another 167 hours, so that the final expiration time is no more than 7 days from the time of the request.

### Extending with an Absolute Time

```bash
curl -X PATCH \
  "$MODELVERSE_BASE_URL/v1beta/cachedContents/cache_abc123" \
  -H "Authorization: Bearer $MODELVERSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "expire_time": "2026-07-24T12:00:00Z"
  }'
```

The new `expire_time` must be later than the current expiration time, at least 60 seconds later than the request time, and no more than 7 days from the time of the request.

The client does not need to query or send back the old expiration time; the server reads and validates the current state of the cache.

### Update Response

```json
{
  "cache_id": "cache_abc123",
  "model": "gemini-2.5-flash",
  "display_name": "product-manual",
  "status": "active",
  "created_at": "2026-07-24T02:00:00Z",
  "updated_at": "2026-07-24T02:10:00Z",
  "old_expire_time": "2026-07-24T03:00:00Z",
  "expire_time": "2026-07-24T03:10:00Z"
}
```

`old_expire_time` is the actual expiration time before the update, and `expire_time` is the expiration time actually in effect upstream after the update.

## Caching Text and Media

### Part Composition Rules

`contents[].parts[]` supports:

- `text`: text.
- `inlineData`: a Base64-encoded blob.

The same `parts` array can contain multiple text parts and blobs at the same time, but each part must be one or the other:

```json
{
  "parts": [
    {
      "text": "This text explains the image that follows."
    },
    {
      "inlineData": {
        "mimeType": "image/jpeg",
        "data": "<IMAGE_BASE64>"
      }
    }
  ]
}
```

The following is invalid, because the same part contains both `text` and `inlineData`:

```json
{
  "text": "Incorrect example",
  "inlineData": {
    "mimeType": "image/jpeg",
    "data": "<IMAGE_BASE64>"
  }
}
```

`systemInstruction.parts[]` supports `text` only; media must be placed in `contents[].parts[].inlineData`.

### `inlineData` Fields

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `mimeType` | string | Yes | The standard MIME type of the file; must match the actual content. |
| `data` | string | Yes | The Base64 string of the file content; do not add a Data URL prefix. |
| `displayName` | string | No | A name that makes the file easier for the model and the caller to identify. |

The total decoded binary size of all `inlineData` must not exceed 10 MiB. `fileData`, Cloud Storage URIs, and local file paths are not supported.

### Common Gemini MIME Types

ModelVerse does not impose an additional model-agnostic MIME whitelist on the caching APIs. Which media formats a cache can use depends on the multimodal input capabilities of the selected Gemini model.

The table below lists the media MIME types commonly used by Gemini models. The PNG, JPEG, PDF, MP3, and MP4 caching examples in this document have been verified with `gemini-2.5-flash`; when using other formats or switching to another supported model in the table above, refer to Google's official documentation for the corresponding model.

| Content | File format | `mimeType` |
| --- | --- | --- |
| Image | PNG | `image/png` |
| Image | JPEG/JPG | `image/jpeg` |
| Image | WebP | `image/webp` |
| Image | HEIC | `image/heic` |
| Image | HEIF | `image/heif` |
| Document | PDF | `application/pdf` |
| Document | TXT | `text/plain` |
| Audio | AAC | `audio/x-aac` |
| Audio | FLAC | `audio/flac` |
| Audio | MP3 | `audio/mp3`, `audio/mpeg` |
| Audio | M4A | `audio/m4a` |
| Audio | MPGA | `audio/mpga` |
| Audio | MP4 Audio | `audio/mp4` |
| Audio | OGG | `audio/ogg` |
| Audio | PCM | `audio/pcm` |
| Audio | WAV | `audio/wav` |
| Audio | WebM Audio | `audio/webm` |
| Video | FLV | `video/x-flv` |
| Video | MOV/QuickTime | `video/quicktime` |
| Video | MPEG | `video/mpeg`, `video/mpegs` |
| Video | MPG | `video/mpg` |
| Video | MP4 | `video/mp4` |
| Video | WebM | `video/webm` |
| Video | WMV | `video/wmv` |
| Video | 3GPP | `video/3gpp` |

Do not assume that MIME types not listed here are supported. When switching models, review the media capabilities of the corresponding model again.

Refer to the official Google Vertex documentation:

- [Context caching overview](https://cloud.google.com/vertex-ai/generative-ai/docs/context-cache/context-cache-overview)
- [Create a context cache](https://cloud.google.com/vertex-ai/generative-ai/docs/context-cache/context-cache-create)
- [Gemini 2.5 Flash](https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash)

### Generating Base64

macOS:

```bash
base64 -i product-manual.pdf | tr -d '\n'
```

Linux:

```bash
base64 -w 0 product-manual.pdf
```

Put the complete output into `inlineData.data`. Do not add a Data URL prefix such as `data:application/pdf;base64,`.

## More Creation Examples

The following examples show only the JSON request body sent to `POST /v1beta/cachedContents`.

Each example must meet the minimum cache token count of the selected model; the Gemini 2 series examples used in this document require at least 2,048 tokens. The total decoded binary size of all `inlineData` must not exceed 10 MiB. `<..._BASE64>` is a placeholder that must be replaced with the complete Base64 content in real calls.

### Text and an Image

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "product-image-context",
  "ttl": "3600s",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "This is a screenshot of the product console. The blue area indicates the available quota, and the gray area indicates the used quota."
        },
        {
          "inlineData": {
            "mimeType": "image/png",
            "data": "<IMAGE_BASE64>",
            "displayName": "console.png"
          }
        },
        {
          "text": "Subsequent answers must explain the screenshot based on the meaning of the interface described above."
        }
      ]
    }
  ]
}
```

### PDF and a Text Description

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "product-manual",
  "ttl": "7200s",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "inlineData": {
            "mimeType": "application/pdf",
            "data": "<PDF_BASE64>",
            "displayName": "product-manual.pdf"
          }
        },
        {
          "text": "Answer subsequent questions based on this product manual first; state explicitly when the manual contains no relevant information."
        }
      ]
    }
  ]
}
```

### Text and Multiple Images

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "device-images",
  "ttl": "3600s",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "The first image is the front of the device:"
        },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "<FRONT_IMAGE_BASE64>",
            "displayName": "device-front.jpg"
          }
        },
        {
          "text": "The second image is the back of the device:"
        },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "<BACK_IMAGE_BASE64>",
            "displayName": "device-back.jpg"
          }
        }
      ]
    }
  ]
}
```

### Audio and a Background Glossary

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "meeting-audio",
  "ttl": "3600s",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Background glossary: ModelVerse is a product name, UMInfer is a service name, and UCloud is a company name."
        },
        {
          "inlineData": {
            "mimeType": "audio/mpeg",
            "data": "<AUDIO_BASE64>",
            "displayName": "weekly-meeting.mp3"
          }
        },
        {
          "text": "Preserve the capitalization of the proper nouns above when generating summaries later."
        }
      ]
    }
  ]
}
```

### Video and Analysis Requirements

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "console-demo-video",
  "ttl": "3600s",
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "inlineData": {
            "mimeType": "video/mp4",
            "data": "<VIDEO_BASE64>",
            "displayName": "console-demo.mp4"
          }
        },
        {
          "text": "This is a screen recording of console operations. Subsequent answers must distinguish between page navigation, user input, and system responses."
        }
      ]
    }
  ]
}
```

### System Rules, Multi-Turn Text, and an Image

`contents` can contain multiple `user` and `model` messages, which is useful for caching fixed multimodal few-shot examples:

```json
{
  "model": "gemini-2.5-flash",
  "displayName": "inspection-examples",
  "ttl": "3600s",
  "systemInstruction": {
    "parts": [
      {
        "text": "You are a device inspection assistant and must output in three sections: Appearance, Ports, and Risks."
      }
    ]
  },
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Please inspect this sample device."
        },
        {
          "inlineData": {
            "mimeType": "image/jpeg",
            "data": "<SAMPLE_IMAGE_BASE64>",
            "displayName": "sample-device.jpg"
          }
        }
      ]
    },
    {
      "role": "model",
      "parts": [
        {
          "text": "Appearance: the casing is intact. Ports: no obstructions. Risks: no obvious risks found."
        }
      ]
    }
  ]
}
```

## Field Naming Compatibility

The APIs accept both the camelCase and snake_case forms in the table below. This document uses whichever form matches the response structure of the API being described:

| camelCase | snake_case |
| --- | --- |
| `displayName` | `display_name` |
| `systemInstruction` | `system_instruction` |
| `inlineData` | `inline_data` |
| `mimeType` | `mime_type` |
| `cachedContent` | `cached_content` |
| `expireTime` | `expire_time` |

The camelCase and snake_case forms of the same field must not be passed at the same time.

## Lifecycle and Billing

- When a cache is created, all tokens in the cache incur a one-time input charge.
- The cache is stored from `created_at` until `expire_time`, which incurs a storage charge.
- Extending a cache only charges for the additional storage between the original expiration time and the new expiration time; the creation input charge is not applied again.
- When generating content with a cache, cached tokens are billed as cache reads; the new question and the output of that request are billed under the normal rules.
- Use `usageMetadata.cachedContentTokenCount` in the response to confirm how many tokens were served from the cache.
- Using a cache does not automatically refresh its validity period; you must extend it explicitly with a PATCH request.
- The final `expire_time` after creation and after each update cannot be more than 7 days from the time of the corresponding request.
- There is currently no API for manual deletion; a cache expires automatically when it reaches `expire_time` and disappears from the List results.

For actual prices, refer to the ModelVerse billing description.

## Common Errors

| HTTP status code | Common cause | Suggested action |
| --- | --- | --- |
| 400 | Malformed JSON or field format | Check the field names, part structure, and Base64 content. |
| 400 | The model is not in the explicit caching support list, and the response indicates `no node` | Use a model listed in the supported models table in this document. |
| 400 | The cache content is below the model's minimum token count | The Gemini 2 series currently requires at least 2,048 tokens, and the Gemini 3 series at least 4,096 tokens. |
| 400 | Both `ttl` and `expire_time` were provided | Keep only one of the two fields. |
| 400 | `ttl` is less than 60 seconds, the new expiration time is not later than the current one, or the final expiration time exceeds 7 days from the request time | Adjust the validity period so that the new time is later than the current expiration time and within the 7-day limit. |
| 400 | The model does not match when using the cache | Use the same model that was used to create the cache. |
| 400 | The API Key does not have permission for the model | Grant the current API Key permission for the model in the console. |
| 400 | `fileData` was passed, or the media exceeds 10 MiB | Use `inlineData` instead, and compress or reduce the media; the total decoded size of multiple blobs still must not exceed 10 MiB. |
| 401 | The API Key is missing or invalid | Check the `Authorization: Bearer` header. |
| 403 | The account status or upstream permissions do not allow the operation | Check the account status; contact technical support if the problem persists. |
| 404 | The cache does not exist, has expired, or does not belong to the current API Key | Check the `cache_id`, API Key, and `expire_time`. |
| 429 | An update to the same cache is already in progress, or upstream rate limiting was triggered | Wait and retry, and avoid concurrent updates to the same cache. |
| 5xx | Gateway or upstream service error | Record the `trace_id` in the response, retry later, or contact technical support. |

## FAQ

### Which models are supported?

Currently `gemini-2.5-flash`, `gemini-3.5-flash-lite`, `gemini-3.5-flash`, `gemini-3.6-flash`, `gemini-3.1-pro-preview`, and `gemini-3-flash-preview` are supported. Other Gemini models supported by the regular generation APIs do not necessarily support explicit caching; refer to the supported models table in this document before creating a cache.

### Is only `systemInstruction` cached?

No. The `systemInstruction` and `contents` in the creation request together form a single cache. `model` binds the cache to a model, while `displayName` and the validity fields are cache metadata.

If you only need to cache a block of fixed system rules, you may pass only `systemInstruction` and omit `contents`; however, the system rules themselves must still meet the minimum cache token count of the selected model.

### Are new questions automatically written into the cache after it is used?

No. The new `contents` in each generation request are used only for that inference and do not modify the original cache.

### Do I need to pass the old expiration time when updating a cache?

No. Pass only the `ttl` to add, or the new absolute `expire_time`. The final expiration time after the update cannot be more than 7 days from the time of the request. The response returns `old_expire_time` and the new `expire_time` that actually took effect.

### Can other API Keys of the same company use this cache?

No. A cache belongs strictly to the API Key that created it.

### Can I use the full cache resource name returned by Google?

No. You can only use the `cache_id` from the ModelVerse creation response.

### Can I modify or delete the cache content early?

Not currently. Cache content cannot be modified after creation — only the validity period can be extended, and the cache expires automatically when its time is up.