diff --git a/storagecontrol/composer.json b/storagecontrol/composer.json
index 76be4bb14..9514b416d 100644
--- a/storagecontrol/composer.json
+++ b/storagecontrol/composer.json
@@ -1,6 +1,6 @@
 {
     "require": {
-        "google/cloud-storage-control": "^1.9"
+        "google/cloud-storage-control": "^1.12"
     },
     "require-dev": {
         "google/cloud-storage": "^1.48.1"
diff --git a/storagecontrol/src/create_rapid_cache.php b/storagecontrol/src/create_rapid_cache.php
new file mode 100644
index 000000000..4e9b5993d
--- /dev/null
+++ b/storagecontrol/src/create_rapid_cache.php
@@ -0,0 +1,86 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * For instructions on how to run the full sample:
+ *
+ * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/main/storagecontrol/README.md
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+# [START storage_control_create_rapid_cache]
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\CreateRapidCacheRequest;
+use Google\Cloud\Storage\Control\V2\RapidCache;
+use Google\Protobuf\Duration;
+
+/**
+ * Creates a Rapid Cache instance.
+ *
+ * @param string $bucketName The name of your Cloud Storage bucket.
+ *        (e.g. 'my-bucket')
+ * @param string $zone The zone in which to create the Rapid Cache. The zone
+ *        must be in the same region as the bucket.
+ *        (e.g. 'us-central1-a')
+ */
+function create_rapid_cache(string $bucketName, string $zone): void
+{
+    $storageControlClient = new StorageControlClient();
+
+    // Set project to "_" to signify global bucket
+    $formattedParent = $storageControlClient->bucketName('_', $bucketName);
+
+    // The Rapid Cache ID must be the same as the zone.
+    $formattedName = $storageControlClient->rapidCacheName('_', $bucketName, $zone);
+
+    // Rapid Cache Ultra requires a bucket with hierarchical namespace enabled.
+    $rapidCache = new RapidCache([
+        'name' => $formattedName,
+        'zone' => $zone,
+        'cache_type' => 'rapid-cache-ultra',
+        // Time to live (TTL) for cache entries: 86400 seconds (24 hours).
+        'ttl' => new Duration(['seconds' => 86400]),
+    ]);
+
+    $request = new CreateRapidCacheRequest([
+        'parent' => $formattedParent,
+        'rapid_cache' => $rapidCache,
+    ]);
+
+    // Creating a Rapid Cache is a long-running operation. This sample blocks
+    // until it completes. A totalPollTimeoutMillis of 0 waits with no time
+    // limit, instead of the client library default of 5 minutes.
+    $operation = $storageControlClient->createRapidCache($request);
+    $operation->pollUntilComplete(['totalPollTimeoutMillis' => 0]);
+
+    if (!$operation->operationSucceeded()) {
+        printf('Error: %s' . PHP_EOL, $operation->getError()->getMessage());
+        return;
+    }
+
+    /** @var RapidCache $rapidCacheResult */
+    $rapidCacheResult = $operation->getResult();
+    printf('Created Rapid Cache: %s' . PHP_EOL, $rapidCacheResult->getName());
+    printf('State: %s' . PHP_EOL, $rapidCacheResult->getState());
+}
+# [END storage_control_create_rapid_cache]
+
+// The following 2 lines are only needed to run the samples
+require_once __DIR__ . '/../../testing/sample_helpers.php';
+\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);
diff --git a/storagecontrol/src/disable_rapid_cache.php b/storagecontrol/src/disable_rapid_cache.php
new file mode 100644
index 000000000..3f46e6c99
--- /dev/null
+++ b/storagecontrol/src/disable_rapid_cache.php
@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * For instructions on how to run the full sample:
+ *
+ * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/main/storagecontrol/README.md
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+# [START storage_control_disable_rapid_cache]
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\DisableRapidCacheRequest;
+use Google\Cloud\Storage\Control\V2\RapidCache;
+
+/**
+ * Disables a Rapid Cache instance.
+ *
+ * @param string $bucketName The name of your Cloud Storage bucket.
+ *        (e.g. 'my-bucket')
+ * @param string $rapidCacheId The ID of the Rapid Cache.
+ *        (e.g. 'us-central1-a')
+ * @param int $timeoutMillis Optional. The maximum time to wait for the
+ *        operation to complete, in milliseconds. 0 waits until it completes.
+ *        (e.g. 600000 for 10 minutes)
+ */
+function disable_rapid_cache(string $bucketName, string $rapidCacheId, int $timeoutMillis = 0): void
+{
+    $storageControlClient = new StorageControlClient();
+
+    // Set project to "_" to signify global bucket
+    $formattedName = $storageControlClient->rapidCacheName('_', $bucketName, $rapidCacheId);
+
+    $request = new DisableRapidCacheRequest([
+        'name' => $formattedName,
+    ]);
+
+    // Disabling a Rapid Cache is a long-running operation. This sample waits
+    // for the long-running operation to complete. A totalPollTimeoutMillis of
+    // 0 waits with no time limit.
+    $operation = $storageControlClient->disableRapidCache($request);
+    $completed = $operation->pollUntilComplete([
+        'totalPollTimeoutMillis' => $timeoutMillis,
+    ]);
+
+    if (!$completed) {
+        printf('Disable operation is still running: %s' . PHP_EOL, $operation->getName());
+        return;
+    }
+
+    if (!$operation->operationSucceeded()) {
+        printf('Error: %s' . PHP_EOL, $operation->getError()->getMessage());
+        return;
+    }
+
+    /** @var RapidCache $rapidCacheResult */
+    $rapidCacheResult = $operation->getResult();
+    printf('Disabled Rapid Cache: %s' . PHP_EOL, $rapidCacheResult->getName());
+}
+# [END storage_control_disable_rapid_cache]
+
+// The following 2 lines are only needed to run the samples
+require_once __DIR__ . '/../../testing/sample_helpers.php';
+\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);
diff --git a/storagecontrol/src/get_rapid_cache.php b/storagecontrol/src/get_rapid_cache.php
new file mode 100644
index 000000000..6960afab9
--- /dev/null
+++ b/storagecontrol/src/get_rapid_cache.php
@@ -0,0 +1,61 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * For instructions on how to run the full sample:
+ *
+ * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/main/storagecontrol/README.md
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+# [START storage_control_get_rapid_cache]
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\GetRapidCacheRequest;
+
+/**
+ * Gets a Rapid Cache instance.
+ *
+ * @param string $bucketName The name of your Cloud Storage bucket.
+ *        (e.g. 'my-bucket')
+ * @param string $rapidCacheId The ID of the Rapid Cache.
+ *        (e.g. 'us-central1-a')
+ */
+function get_rapid_cache(string $bucketName, string $rapidCacheId): void
+{
+    $storageControlClient = new StorageControlClient();
+
+    // Set project to "_" to signify global bucket
+    $formattedName = $storageControlClient->rapidCacheName('_', $bucketName, $rapidCacheId);
+
+    $request = new GetRapidCacheRequest([
+        'name' => $formattedName,
+    ]);
+
+    $response = $storageControlClient->getRapidCache($request);
+
+    printf('Got Rapid Cache: %s' . PHP_EOL, $response->getName());
+    printf('Zone: %s' . PHP_EOL, $response->getZone());
+    printf('Cache type: %s' . PHP_EOL, $response->getCacheType());
+    printf('State: %s' . PHP_EOL, $response->getState());
+}
+# [END storage_control_get_rapid_cache]
+
+// The following 2 lines are only needed to run the samples
+require_once __DIR__ . '/../../testing/sample_helpers.php';
+\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);
diff --git a/storagecontrol/src/list_rapid_caches.php b/storagecontrol/src/list_rapid_caches.php
new file mode 100644
index 000000000..e2bbe8f9a
--- /dev/null
+++ b/storagecontrol/src/list_rapid_caches.php
@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * For instructions on how to run the full sample:
+ *
+ * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/main/storagecontrol/README.md
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+# [START storage_control_list_rapid_caches]
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\ListRapidCachesRequest;
+
+/**
+ * Lists Rapid Cache instances for a given bucket.
+ *
+ * @param string $bucketName The name of your Cloud Storage bucket.
+ *        (e.g. 'my-bucket')
+ */
+function list_rapid_caches(string $bucketName): void
+{
+    $storageControlClient = new StorageControlClient();
+
+    // Set project to "_" to signify global bucket
+    $formattedName = $storageControlClient->bucketName('_', $bucketName);
+
+    $request = new ListRapidCachesRequest([
+        'parent' => $formattedName,
+    ]);
+
+    $response = $storageControlClient->listRapidCaches($request);
+
+    // The iterator handles pagination automatically.
+    foreach ($response as $rapidCache) {
+        printf('Rapid Cache name: %s' . PHP_EOL, $rapidCache->getName());
+    }
+}
+# [END storage_control_list_rapid_caches]
+
+// The following 2 lines are only needed to run the samples
+require_once __DIR__ . '/../../testing/sample_helpers.php';
+\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);
diff --git a/storagecontrol/src/update_rapid_cache.php b/storagecontrol/src/update_rapid_cache.php
new file mode 100644
index 000000000..6425505f9
--- /dev/null
+++ b/storagecontrol/src/update_rapid_cache.php
@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * For instructions on how to run the full sample:
+ *
+ * @see https://github.com/GoogleCloudPlatform/php-docs-samples/tree/main/storagecontrol/README.md
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+# [START storage_control_update_rapid_cache]
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\RapidCache;
+use Google\Cloud\Storage\Control\V2\UpdateRapidCacheRequest;
+use Google\Protobuf\Duration;
+use Google\Protobuf\FieldMask;
+
+/**
+ * Updates the time to live (TTL) of a Rapid Cache instance.
+ *
+ * @param string $bucketName The name of your Cloud Storage bucket.
+ *        (e.g. 'my-bucket')
+ * @param string $rapidCacheId The ID of the Rapid Cache.
+ *        (e.g. 'us-central1-a')
+ * @param int $ttlSeconds The new TTL for cache entries, in seconds. The TTL
+ *        must be between 1 hour and 7 days.
+ *        (e.g. 172800 for 2 days)
+ */
+function update_rapid_cache(string $bucketName, string $rapidCacheId, int $ttlSeconds): void
+{
+    $storageControlClient = new StorageControlClient();
+
+    // Set project to "_" to signify global bucket
+    $formattedName = $storageControlClient->rapidCacheName('_', $bucketName, $rapidCacheId);
+
+    $rapidCache = new RapidCache([
+        'name' => $formattedName,
+        'ttl' => new Duration(['seconds' => $ttlSeconds]),
+    ]);
+
+    // Only the fields listed in the update mask are changed.
+    $updateMask = new FieldMask([
+        'paths' => ['ttl'],
+    ]);
+
+    $request = new UpdateRapidCacheRequest([
+        'rapid_cache' => $rapidCache,
+        'update_mask' => $updateMask,
+    ]);
+
+    // Updating a Rapid Cache is a long-running operation. This sample blocks
+    // until it completes. A totalPollTimeoutMillis of 0 waits with no time
+    // limit, instead of the client library default of 5 minutes.
+    $operation = $storageControlClient->updateRapidCache($request);
+    $operation->pollUntilComplete(['totalPollTimeoutMillis' => 0]);
+
+    if (!$operation->operationSucceeded()) {
+        printf('Error: %s' . PHP_EOL, $operation->getError()->getMessage());
+        return;
+    }
+
+    /** @var RapidCache $rapidCacheResult */
+    $rapidCacheResult = $operation->getResult();
+    printf('Updated Rapid Cache: %s' . PHP_EOL, $rapidCacheResult->getName());
+    printf('TTL: %d seconds' . PHP_EOL, $rapidCacheResult->getTtl()->getSeconds());
+}
+# [END storage_control_update_rapid_cache]
+
+// The following 2 lines are only needed to run the samples
+require_once __DIR__ . '/../../testing/sample_helpers.php';
+\Google\Cloud\Samples\execute_sample(__FILE__, __NAMESPACE__, $argv);
diff --git a/storagecontrol/test/rapidCacheTest.php b/storagecontrol/test/rapidCacheTest.php
new file mode 100644
index 000000000..83dc1c26a
--- /dev/null
+++ b/storagecontrol/test/rapidCacheTest.php
@@ -0,0 +1,175 @@
+<?php
+
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Cloud\Samples\StorageControl;
+
+use Google\Cloud\Core\Exception\ConflictException;
+use Google\Cloud\Storage\Control\V2\Client\StorageControlClient;
+use Google\Cloud\Storage\Control\V2\DisableRapidCacheRequest;
+use Google\Cloud\Storage\StorageClient;
+use Google\Cloud\TestUtils\TestTrait;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Tests for the Rapid Cache storage control samples.
+ */
+class rapidCacheTest extends TestCase
+{
+    use TestTrait;
+
+    // Wait for bucket metadata to propagate before creating the Rapid Cache.
+    private const BUCKET_PROPAGATION_SECONDS = 20;
+
+    // Maximum time to wait for the disable operation (10 minutes). The cache
+    // moves to the "disabled" state within seconds, but the operation itself
+    // can run for more than an hour.
+    private const DISABLE_TIMEOUT_MILLIS = 600000;
+
+    // Best-effort bucket cleanup: retry for up to ~2 minutes.
+    private const DELETE_RETRY_ATTEMPTS = 6;
+    private const DELETE_RETRY_INTERVAL_SECONDS = 20;
+
+    private static $sourceBucket;
+    private static $storage;
+    private static $location;
+    private static $zone;
+    private static $cacheName;
+    private static $cacheDisabled = false;
+
+    public static function setUpBeforeClass(): void
+    {
+        self::checkProjectEnvVars();
+        self::$storage = new StorageClient();
+        self::$zone = getenv('RAPID_CACHE_ZONE') ?: 'us-central1-a';
+        // The bucket must be in the same region as the Rapid Cache zone.
+        self::$location = substr(self::$zone, 0, strrpos(self::$zone, '-'));
+        $uniqueBucketId = time() . rand();
+        // Rapid Cache Ultra requires a regional bucket with hierarchical
+        // namespace enabled.
+        self::$sourceBucket = self::$storage->createBucket(
+            sprintf('php-gcscontrol-rc-%s', $uniqueBucketId),
+            [
+                'location' => self::$location,
+                'hierarchicalNamespace' => ['enabled' => true],
+                'iamConfiguration' => ['uniformBucketLevelAccess' => ['enabled' => true]]
+            ]
+        );
+        sleep(self::BUCKET_PROPAGATION_SECONDS);
+    }
+
+    public static function tearDownAfterClass(): void
+    {
+        if (!self::$sourceBucket) {
+            return;
+        }
+        // Disable the Rapid Cache if the test did not, so that the bucket can
+        // be deleted once the cache has been removed. Errors are ignored.
+        if (self::$cacheName && !self::$cacheDisabled) {
+            try {
+                $storageControlClient = new StorageControlClient();
+                $storageControlClient->disableRapidCache(new DisableRapidCacheRequest([
+                    'name' => self::$cacheName,
+                ]));
+            } catch (\Exception $e) {
+                // Ignore errors: the cache may already be disabled.
+            }
+        }
+        // A bucket cannot be deleted until its disabled Rapid Cache has been
+        // fully removed, which can take more than two hours. Cleanup is
+        // best-effort: a short retry, after which the bucket is left behind
+        // for later cleanup.
+        for ($attempt = 1; $attempt <= self::DELETE_RETRY_ATTEMPTS; $attempt++) {
+            try {
+                self::$sourceBucket->delete();
+                return;
+            } catch (ConflictException $e) {
+                if ($attempt < self::DELETE_RETRY_ATTEMPTS) {
+                    sleep(self::DELETE_RETRY_INTERVAL_SECONDS);
+                }
+            } catch (\Exception $e) {
+                break;
+            }
+        }
+        fwrite(STDERR, sprintf(
+            'Could not delete bucket %s: %s' . PHP_EOL,
+            self::$sourceBucket->name(),
+            isset($e) ? $e->getMessage() : 'unknown error'
+        ));
+    }
+
+    public function testRapidCacheLifecycle()
+    {
+        $bucketName = self::$sourceBucket->name();
+        // The Rapid Cache ID must be the same as the zone.
+        $cacheId = self::$zone;
+        $cacheName = StorageControlClient::rapidCacheName('_', $bucketName, $cacheId);
+        self::$cacheName = $cacheName;
+
+        // Test create Rapid Cache
+        $output = $this->runFunctionSnippet('create_rapid_cache', [
+            $bucketName,
+            self::$zone,
+        ]);
+        $this->assertStringContainsString(sprintf('Created Rapid Cache: %s', $cacheName), $output);
+
+        // Test get Rapid Cache
+        $output = $this->runFunctionSnippet('get_rapid_cache', [
+            $bucketName,
+            $cacheId,
+        ]);
+        $this->assertStringContainsString(sprintf('Got Rapid Cache: %s', $cacheName), $output);
+        $this->assertStringContainsString(sprintf('Zone: %s', self::$zone), $output);
+        $this->assertStringContainsString('Cache type: rapid-cache-ultra', $output);
+        $this->assertStringContainsString('State: running', $output);
+
+        // Test list Rapid Caches
+        $output = $this->runFunctionSnippet('list_rapid_caches', [
+            $bucketName,
+        ]);
+        $this->assertStringContainsString(sprintf('Rapid Cache name: %s', $cacheName), $output);
+
+        // Test update Rapid Cache
+        $output = $this->runFunctionSnippet('update_rapid_cache', [
+            $bucketName,
+            $cacheId,
+            172800,
+        ]);
+        $this->assertStringContainsString(sprintf('Updated Rapid Cache: %s', $cacheName), $output);
+        $this->assertStringContainsString('TTL: 172800 seconds', $output);
+
+        // Test disable Rapid Cache, with a bounded wait so that the test
+        // cannot hang on the long-running operation.
+        $output = $this->runFunctionSnippet('disable_rapid_cache', [
+            $bucketName,
+            $cacheId,
+            self::DISABLE_TIMEOUT_MILLIS,
+        ]);
+        self::$cacheDisabled = true;
+        if (str_contains($output, 'Disable operation is still running')) {
+            // The operation did not finish in time; the cache state must
+            // already show "disabled".
+            $output = $this->runFunctionSnippet('get_rapid_cache', [
+                $bucketName,
+                $cacheId,
+            ]);
+            $this->assertStringContainsString('State: disabled', $output);
+        } else {
+            $this->assertStringContainsString(sprintf('Disabled Rapid Cache: %s', $cacheName), $output);
+        }
+    }
+}