This page shows you how to change the *default storage class* for a [bucket](https://docs.cloud.google.com/storage/docs/buckets.md.txt).
When you upload an object to the bucket, if you don't specify a storage class
for the object, the object is assigned the bucket's default storage class. To
learn more about storage classes, see [Storage Classes](https://docs.cloud.google.com/storage/docs/storage-classes.md.txt).

## Required roles

In order to get the required permissions for changing a bucket's storage class,
ask your administrator to grant you the Storage Admin
(`roles/storage.admin`) IAM role on the bucket.

This [predefined role](https://docs.cloud.google.com/iam/docs/understanding-roles) contains the permissions required to change a
bucket's storage class. To see the exact permissions that are required, expand
the **Required permissions** section:

#### Required permissions

- `storage.buckets.get`
  - This permission is only required if you plan on using the Google Cloud console to perform the instructions on this page.
- `storage.buckets.list`
  - This permission is only required if you plan on using the Google Cloud console to perform the instructions on this page.
- `storage.buckets.update`

You might also be able to get these permissions with [custom roles](https://docs.cloud.google.com/iam/docs/creating-custom-roles.md.txt).

For instructions on granting roles on buckets, see
[Set and manage IAM policies on buckets](https://docs.cloud.google.com/storage/docs/access-control/using-iam-permissions.md.txt).

## Change the default storage class of a bucket

### Console

1. In the Google Cloud console, go to the Cloud Storage **Buckets** page.  

   [Go to Buckets](https://console.cloud.google.com/storage/browser)
2. In the list of buckets, click the name of the bucket whose storage class
   you want to change.

3. In the **Bucket details** page, click the **Configuration** tab.

4. Click the **Edit** icon
   ()
   for **Default storage class**.

5. In the overlay window, select the new default storage class you would
   like for your bucket.

6. Click **Save**.

To learn how to get detailed error information about failed Cloud Storage
operations in the Google Cloud console, see
[Troubleshooting](https://docs.cloud.google.com/storage/docs/troubleshooting.md.txt#trouble-console).

### Command line

Use the [`gcloud storage buckets update`](https://docs.cloud.google.com/sdk/gcloud/reference/storage/buckets/update) command with the
`--default-storage-class` flag:

```
gcloud storage buckets update gs://BUCKET_NAME --default-storage-class=STORAGE_CLASS
```

Where:

- `BUCKET_NAME` is the name of the relevant bucket. For example, `my-bucket`.
- `STORAGE_CLASS` is the new [storage class](https://docs.cloud.google.com/storage/docs/storage-classes.md.txt) you want for your bucket. For example, `nearline`.

The response looks like the following example:

```
Setting default storage class to "nearline" for bucket gs://my-bucket
```

### Client libraries


### C++


For more information, see the
[Cloud Storage C++ API
reference documentation](https://docs.cloud.google.com/cpp/docs/reference/storage/latest).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```c++
namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& storage_class) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);
  if (!original) throw std::move(original).status();

  gcs::BucketMetadata desired = *original;
  desired.set_storage_class(storage_class);

  StatusOr<gcs::BucketMetadata> patched =
      client.PatchBucket(bucket_name, *original, desired);
  if (!patched) throw std::move(patched).status();

  std::cout << "Storage class for bucket " << patched->name()
            << " has been patched to " << patched->storage_class() << "."
            << "\nFull metadata: " << *patched << "\n";
}
```

### C#


For more information, see the
[Cloud Storage C# API
reference documentation](https://cloud.google.com/dotnet/docs/reference/Google.Cloud.Storage.V1/latest).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```c#

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class ChangeDefaultStorageClassSample
{
	public Bucket ChangeDefaultStorageClass(string bucketName = "your-bucket-name", string storageClass = StorageClasses.Standard)
	{
	    var storage = StorageClient.Create();
	    var bucket = storage.GetBucket(bucketName);

	    bucket.StorageClass = storageClass;

	    bucket = storage.UpdateBucket(bucket);
	    Console.WriteLine($"Default storage class for bucket {bucketName} changed to {storageClass}.");
	    return bucket;
	}
}
```

### Go


For more information, see the
[Cloud Storage Go API
reference documentation](https://pkg.go.dev/cloud.google.com/go/storage).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```go
import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// changeDefaultStorageClass changes the storage class on a bucket.
func changeDefaultStorageClass(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	newStorageClass := "COLDLINE"
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		StorageClass: newStorageClass,
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Default storage class for bucket %v has been set to %v\n", bucketName, newStorageClass)
	return nil
}
```

### Java


For more information, see the
[Cloud Storage Java API
reference documentation](https://cloud.google.com/java/docs/reference/google-cloud-storage/latest/overview).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```java
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class ChangeDefaultStorageClass {
  public static void changeDefaultStorageClass(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    bucket = bucket.toBuilder().setStorageClass(storageClass).build().update();

    System.out.println(
        "Default storage class for bucket "
            + bucketName
            + " has been set to "
            + bucket.getStorageClass());
  }
}
```

### Node.js


For more information, see the
[Cloud Storage Node.js API
reference documentation](https://cloud.google.com/nodejs/docs/reference/storage/latest).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```javascript
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function changeDefaultStorageClass() {
  await storage.bucket(bucketName).setStorageClass(storageClass);

  console.log(`${bucketName} has been set to ${storageClass}`);
}

changeDefaultStorageClass().catch(console.error);
```

### PHP


For more information, see the
[Cloud Storage PHP API
reference documentation](https://googleapis.github.io/google-cloud-php/#/docs/google-cloud/latest/storage/storageclient).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```php
use Google\Cloud\Storage\StorageClient;

/**
 * Change the default storage class for the given bucket.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function change_default_storage_class(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $storageClass = 'COLDLINE';

    $bucket->update([
        'storageClass' => $storageClass,
    ]);

    printf(
        'Default storage class for bucket %s has been set to %s',
        $bucketName,
        $storageClass
    );
}
```

### Python


For more information, see the
[Cloud Storage Python API
reference documentation](https://cloud.google.com/python/docs/reference/storage/latest).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```python
from google.cloud import storage
from google.cloud.storage import constants


def change_default_storage_class(bucket_name):
    """Change the default storage class of the bucket"""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.storage_class = constants.COLDLINE_STORAGE_CLASS
    bucket.patch()

    print(f"Default storage class for bucket {bucket_name} has been set to {bucket.storage_class}")
    return bucket

```

### Ruby


For more information, see the
[Cloud Storage Ruby API
reference documentation](https://googleapis.dev/ruby/google-cloud-storage/latest/Google/Cloud/Storage.html).


To authenticate to Cloud Storage, set up Application Default Credentials.
For more information, see

[Set up authentication for client libraries](https://docs.cloud.google.com/storage/docs/authentication.md.txt#client-libs).

```ruby
def change_default_storage_class bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.storage_class = "COLDLINE"

  puts "Default storage class for bucket #{bucket_name} has been set to #{bucket.storage_class}"
end
```

### Rust

```rust
use google_cloud_storage::client::StorageControl;
use google_cloud_wkt::FieldMask;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    let bucket = client
        .get_bucket()
        .set_name(format!("projects/_/buckets/{bucket_id}"))
        .send()
        .await?;
    let metageneration = bucket.metageneration;
    let bucket = client
        .update_bucket()
        .set_bucket(bucket.set_storage_class("NEARLINE"))
        .set_if_metageneration_match(metageneration)
        .set_update_mask(FieldMask::default().set_paths(["storage_class"]))
        .send()
        .await?;
    println!("successfully updated bucket {bucket:?}");
    Ok(())
}
```

<br />

### REST APIs

### JSON API

1. Have gcloud CLI [installed and initialized](https://docs.cloud.google.com/sdk/docs/install), which lets
   you generate an access token for the `Authorization` header.

2. Create a JSON file that contains the following information:

   ```json
   {
     "storageClass": "STORAGE_CLASS"
   }
   ```

   Where `STORAGE_CLASS` is the new
   [storage class](https://docs.cloud.google.com/storage/docs/storage-classes.md.txt) you want for your bucket. For example,
   `nearline`.
3. Use [`cURL`](http://curl.haxx.se/) to call the [JSON API](https://docs.cloud.google.com/storage/docs/json_api.md.txt) with a
   [`PATCH` Bucket](https://docs.cloud.google.com/storage/docs/json_api/v1/buckets/patch.md.txt) request:

   ```
   curl -X PATCH --data-binary @JSON_FILE_NAME \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=storageClass"
   ```

   Where:
   - `JSON_FILE_NAME` is the path for the JSON file that you created in Step 2.
   - `BUCKET_NAME` is the name of the relevant bucket. For example, `my-bucket`.

### XML API

1. Have gcloud CLI [installed and initialized](https://docs.cloud.google.com/sdk/docs/install), which lets
   you generate an access token for the `Authorization` header.

2. Create an XML file that contains the following information:

   ```
   <StorageClass>STORAGE_CLASS</StorageClass>
   ```

   Where `STORAGE_CLASS` is the name of the new
   [storage class](https://docs.cloud.google.com/storage/docs/storage-classes.md.txt) you want for your bucket. For example, `nearline`.
3. Use [`cURL`](http://curl.haxx.se/) to call the [XML API](https://docs.cloud.google.com/storage/docs/xml-api/overview.md.txt) with a
   [`PUT` Bucket](https://docs.cloud.google.com/storage/docs/xml-api/put-bucket-metadata.md.txt) request scoped to `?storageClass`:

   ```
   curl -X PUT --data-binary @XML_FILE_NAME \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://storage.googleapis.com/BUCKET_NAME?storageClass"
   ```

   Where:
   - `XML_FILE_NAME` is the path for the XML file that you created in Step 2.
   - `BUCKET_NAME` is the name of the relevant bucket. For example, `my-bucket`.

## What's next

- [Move or rename a bucket](https://docs.cloud.google.com/storage/docs/moving-buckets.md.txt).
- [Upload an object](https://docs.cloud.google.com/storage/docs/uploading-objects.md.txt).
- [Change the storage class of an object](https://docs.cloud.google.com/storage/docs/changing-storage-classes.md.txt).
- [Manage object lifecycles](https://docs.cloud.google.com/storage/docs/managing-lifecycles.md.txt).
- Learn about automatic storage class management using [Autoclass](https://docs.cloud.google.com/storage/docs/autoclass.md.txt).