Console
    Start free

    Set up and view CORS configurations

    Overview Configuration samples

    Cross-origin resource sharing (CORS) allows interactions between resources from different origins, something that is normally prohibited in order to prevent malicious behavior. Use this page to learn how to set a CORS configuration on a Cloud Storage bucket and how to view the CORS configuration set on a bucket. See Configuration examples for CORS for example CORS configurations.

    Required roles

    To get the permissions that you need to set and view the CORS configuration on a bucket, ask your administrator to grant you the Storage Admin ( roles/storage.admin ) role on the bucket.

    This predefined role contains the permissions required to set and view CORS configurations. To see the exact permissions that are required, expand the Required permissionssection:

    Required permissions

    • storage.buckets.get
    • storage.buckets.update

    You can also get these permissions with other predefined roles or custom roles .

    For information about granting roles on buckets, see Set and manage IAM policies on buckets .

    Set the CORS configuration on a bucket

    You set a CORS configuration on a bucket by specifying information, such as HTTP methods and originating domains, that identifies the types of requests the bucket can accept.

    Use the following steps to set a CORS configuration on your bucket:

    Console

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

      Go to Buckets

    2. Click the name of the bucket.

    3. Click the Configurationtab.

    4. In the Cross-origin resource sharingsection, click Edit CORS configuration.

    5. Select the Allow cross-origin resource sharingcheckbox.

    6. Click Add a configuration, and then do the following:

      1. Provide values for the fields in the configuration:

        • List of allowed origins: the origins that you want to allow for cross-origin resource sharing with this bucket.

        • Specify methods: the HTTP methods that you want to allow for cross-origin resource sharing with this bucket.

        • List of allowed response headers: the response headers that you want to allow for cross-origin resource sharing with this bucket.

        • Cache expiry time: the number of seconds the browser is allowed to make requests before it must repeat the preflight request.

        For more information about each field, see Components of a CORS configuration .

      2. Click Done.

    7. Optional: To add additional configurations, repeat the previous step.

    8. Click Save.

    Command line

    1. Create a JSON file with the CORS configuration you would like to apply. See configuration examples for sample JSON files.

    2. Use the gcloud storage buckets update command with the --cors-file flag:

      gcloud storage buckets update gs:// BUCKET_NAME 
--cors-file= CORS_CONFIG_FILE

      Where:

      • BUCKET_NAME is the name of the relevant bucket. For example, my-bucket .
      • CORS_CONFIG_FILE is the path to the JSON file you created in Step 1.

    Client libraries

    C++

    For more information, see the Cloud Storage C++ API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      namespace 
  
 gcs 
  
 = 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 storage 
 ; 
 using 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 StatusOr 
 ; 
 []( 
 gcs 
 :: 
 Client 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 bucket_name 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 origin 
 ) 
  
 { 
  
 StatusOr<gcs 
 :: 
 BucketMetadata 
>  
 original 
  
 = 
  
 client 
 . 
 GetBucketMetadata 
 ( 
 bucket_name 
 ); 
  
 if 
  
 ( 
 ! 
 original 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 original 
 ). 
 status 
 (); 
  
 std 
 :: 
 vector<gcs 
 :: 
 CorsEntry 
>  
 cors_configuration 
 ; 
  
 cors_configuration 
 . 
 emplace_back 
 ( 
  
 gcs 
 :: 
 CorsEntry 
 { 
 3600 
 , 
  
 { 
 "GET" 
 }, 
  
 { 
 origin 
 }, 
  
 { 
 "Content-Type" 
 }}); 
  
 StatusOr<gcs 
 :: 
 BucketMetadata 
>  
 patched 
  
 = 
  
 client 
 . 
 PatchBucket 
 ( 
  
 bucket_name 
 , 
  
 gcs 
 :: 
 BucketMetadataPatchBuilder 
 (). 
 SetCors 
 ( 
 cors_configuration 
 ), 
  
 gcs 
 :: 
 IfMetagenerationMatch 
 ( 
 original 
 - 
> metageneration 
 ())); 
  
 if 
  
 ( 
 ! 
 patched 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 patched 
 ). 
 status 
 (); 
  
 if 
  
 ( 
 patched 
 - 
> cors 
 (). 
 empty 
 ()) 
  
 { 
  
 std 
 :: 
 cout 
 << 
 "Cors configuration is not set for bucket " 
 << 
 patched 
 - 
> name 
 () 
 << 
 " 
 \n 
 " 
 ; 
  
 return 
 ; 
  
 } 
  
 std 
 :: 
 cout 
 << 
 "Cors configuration successfully set for bucket " 
 << 
 patched 
 - 
> name 
 () 
 << 
 " 
 \n 
 New cors configuration: " 
 ; 
  
 for 
  
 ( 
 auto 
  
 const 
&  
 cors_entry 
  
 : 
  
 patched 
 - 
> cors 
 ()) 
  
 { 
  
 std 
 :: 
 cout 
 << 
 " 
 \n 
 " 
 << 
 cors_entry 
 << 
 " 
 \n 
 " 
 ; 
  
 } 
 }

    C#

    For more information, see the Cloud Storage C# API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      using 
  
 Google.Apis.Storage.v1.Data 
 ; 
 using 
  
  Google.Cloud.Storage.V1 
 
 ; 
 using 
  
 System 
 ; 
 using 
  
 System.Collections.Generic 
 ; 
 using 
  
 static 
  
 Google 
 . 
 Apis 
 . 
 Storage 
 . 
 v1 
 . 
 Data 
 . 
 Bucket 
 ; 
 public 
  
 class 
  
 BucketAddCorsConfigurationSample 
 { 
  
 public 
  
 Bucket 
  
 BucketAddCorsConfiguration 
 ( 
 string 
  
 bucketName 
  
 = 
  
 "your-bucket-name" 
 ) 
  
 { 
  
 var 
  
 storage 
  
 = 
  
  StorageClient 
 
 . 
  Create 
 
 (); 
  
 var 
  
 bucket 
  
 = 
  
 storage 
 . 
 GetBucket 
 ( 
 bucketName 
 ); 
  
 CorsData 
  
 corsData 
  
 = 
  
 new 
  
 CorsData 
  
 { 
  
 Origin 
  
 = 
  
 new 
  
 string 
 [] 
  
 { 
  
 "*" 
  
 }, 
  
 ResponseHeader 
  
 = 
  
 new 
  
 string 
 [] 
  
 { 
  
 "Content-Type" 
 , 
  
 "x-goog-resumable" 
  
 }, 
  
 Method 
  
 = 
  
 new 
  
 string 
 [] 
  
 { 
  
 "PUT" 
 , 
  
 "POST" 
  
 }, 
  
 MaxAgeSeconds 
  
 = 
  
 3600 
  
 //One Hour 
  
 }; 
  
 if 
  
 ( 
 bucket 
 . 
 Cors 
  
 == 
  
 null 
 ) 
  
 { 
  
 bucket 
 . 
 Cors 
  
 = 
  
 new 
  
 List<CorsData> 
 (); 
  
 } 
  
 bucket 
 . 
 Cors 
 . 
 Add 
 ( 
 corsData 
 ); 
  
 bucket 
  
 = 
  
 storage 
 . 
 UpdateBucket 
 ( 
 bucket 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"bucketName {bucketName} was updated with a CORS config to allow {string.Join(" 
 , 
 ", corsData.Method)} requests from" 
  
 + 
  
 $" {string.Join(" 
 , 
 ", corsData. Origin 
)} sharing {string.Join(" 
 , 
 ", corsData.ResponseHeader)} responseHeader" 
  
 + 
  
 $" responses across origins." 
 ); 
  
 return 
  
 bucket 
 ; 
  
 } 
 }

    Go

    For more information, see the Cloud Storage Go API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "time" 
  
 "cloud.google.com/go/storage" 
 ) 
 // setBucketCORSConfiguration sets a CORS configuration on a bucket. 
 func 
  
 setBucketCORSConfiguration 
 ( 
 w 
  
 io 
 . 
  Writer 
 
 , 
  
 bucketName 
  
 string 
 , 
  
 maxAge 
  
 time 
 . 
 Duration 
 , 
  
 methods 
 , 
  
 origins 
 , 
  
 responseHeaders 
  
 [] 
 string 
 ) 
  
 error 
  
 { 
  
 // bucketName := "bucket-name" 
  
 // maxAge := time.Hour 
  
 // methods := []string{"GET"} 
  
 // origins := []string{"some-origin.com"} 
  
 // responseHeaders := []string{"Content-Type"} 
  
 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 
 ) 
  
 bucketAttrsToUpdate 
  
 := 
  
 storage 
 . 
  BucketAttrsToUpdate 
 
 { 
  
 CORS 
 : 
  
 [] 
 storage 
 . 
  CORS 
 
 { 
  
 { 
  
 MaxAge 
 : 
  
 maxAge 
 , 
  
 Methods 
 : 
  
 methods 
 , 
  
 Origins 
 : 
  
 origins 
 , 
  
 ResponseHeaders 
 : 
  
 responseHeaders 
 , 
  
 }}, 
  
 } 
  
 if 
  
 _ 
 , 
  
 err 
  
 := 
  
 bucket 
 . 
 Update 
 ( 
 ctx 
 , 
  
 bucketAttrsToUpdate 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "Bucket(%q).Update: %w" 
 , 
  
 bucketName 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Bucket %v was updated with a CORS config to allow %v requests from %v sharing %v responses across origins\n" 
 , 
  
 bucketName 
 , 
  
 methods 
 , 
  
 origins 
 , 
  
 responseHeaders 
 ) 
  
 return 
  
 nil 
 }

    Java

    For more information, see the Cloud Storage Java API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      import 
  
 com.google.cloud.storage. Bucket 
 
 ; 
 import 
  
 com.google.cloud.storage. Cors 
 
 ; 
 import 
  
 com.google.cloud.storage. HttpMethod 
 
 ; 
 import 
  
 com.google.cloud.storage. Storage 
 
 ; 
 import 
  
 com.google.cloud.storage. StorageOptions 
 
 ; 
 import 
  
 com.google.common.collect.ImmutableList 
 ; 
 public 
  
 class 
 ConfigureBucketCors 
  
 { 
  
 public 
  
 static 
  
 void 
  
 configureBucketCors 
 ( 
  
 String 
  
 projectId 
 , 
  
 String 
  
 bucketName 
 , 
  
 String 
  
 origin 
 , 
  
 String 
  
 responseHeader 
 , 
  
 Integer 
  
 maxAgeSeconds 
 ) 
  
 { 
  
 // The ID of your GCP project 
  
 // String projectId = "your-project-id"; 
  
 // The ID of your GCS bucket 
  
 // String bucketName = "your-unique-bucket-name"; 
  
 // The origin for this CORS config to allow requests from 
  
 // String origin = "http://example.appspot.com"; 
  
 // The response header to share across origins 
  
 // String responseHeader = "Content-Type"; 
  
 // The maximum amount of time the browser can make requests before it must repeat preflighted 
  
 // requests 
  
 // Integer maxAgeSeconds = 3600; 
  
  Storage 
 
  
 storage 
  
 = 
  
  StorageOptions 
 
 . 
 newBuilder 
 (). 
 setProjectId 
 ( 
 projectId 
 ). 
 build 
 (). 
  getService 
 
 (); 
  
  Bucket 
 
  
 bucket 
  
 = 
  
 storage 
 . 
  get 
 
 ( 
 bucketName 
 ); 
  
 // See the HttpMethod documentation for other HTTP methods available: 
  
 // https://cloud.google.com/appengine/docs/standard/java/javadoc/com/google/appengine/api/urlfetch/HTTPMethod 
  
  HttpMethod 
 
  
 method 
  
 = 
  
  HttpMethod 
 
 . 
 GET 
 ; 
  
  Cors 
 
  
 cors 
  
 = 
  
  Cors 
 
 . 
 newBuilder 
 () 
  
 . 
  setOrigins 
 
 ( 
 ImmutableList 
 . 
 of 
 ( 
  Cors 
 
 . 
 Origin 
 . 
 of 
 ( 
 origin 
 ))) 
  
 . 
  setMethods 
 
 ( 
 ImmutableList 
 . 
 of 
 ( 
 method 
 )) 
  
 . 
  setResponseHeaders 
 
 ( 
 ImmutableList 
 . 
 of 
 ( 
 responseHeader 
 )) 
  
 . 
  setMaxAgeSeconds 
 
 ( 
 maxAgeSeconds 
 ) 
  
 . 
 build 
 (); 
  
 bucket 
 . 
  toBuilder 
 
 (). 
 setCors 
 ( 
 ImmutableList 
 . 
 of 
 ( 
 cors 
 )). 
 build 
 (). 
 update 
 (); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
  
 "Bucket " 
  
 + 
  
 bucketName 
  
 + 
  
 " was updated with a CORS config to allow GET requests from " 
  
 + 
  
 origin 
  
 + 
  
 " sharing " 
  
 + 
  
 responseHeader 
  
 + 
  
 " responses across origins" 
 ); 
  
 } 
 }

    Node.js

    For more information, see the Cloud Storage Node.js API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      // Imports the Google Cloud client library 
 const 
  
 { 
 Storage 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/storage 
' 
 ); 
 // Creates a client 
 const 
  
 storage 
  
 = 
  
 new 
  
  Storage 
 
 (); 
 /** 
 * TODO(developer): Uncomment the following lines before running the sample. 
 */ 
 // The ID of your GCS bucket 
 // const bucketName = 'your-unique-bucket-name'; 
 // The origin for this CORS config to allow requests from 
 // const origin = 'http://example.appspot.com'; 
 // The response header to share across origins 
 // const responseHeader = 'Content-Type'; 
 // The maximum amount of time the browser can make requests before it must 
 // repeat preflighted requests 
 // const maxAgeSeconds = 3600; 
 // The name of the method 
 // See the HttpMethod documentation for other HTTP methods available: 
 // https://cloud.google.com/appengine/docs/standard/java/javadoc/com/google/appengine/api/urlfetch/HTTPMethod 
 // const method = 'GET'; 
 async 
  
 function 
  
 configureBucketCors 
 () 
  
 { 
  
 await 
  
 storage 
 . 
 bucket 
 ( 
 bucketName 
 ). 
  setCorsConfiguration 
 
 ([ 
  
 { 
  
 maxAgeSeconds 
 , 
  
 method 
 : 
  
 [ 
 method 
 ], 
  
 origin 
 : 
  
 [ 
 origin 
 ], 
  
 responseHeader 
 : 
  
 [ 
 responseHeader 
 ], 
  
 }, 
  
 ]); 
  
 console 
 . 
 log 
 ( 
 `Bucket 
 ${ 
 bucketName 
 } 
 was updated with a CORS config 
 to allow 
 ${ 
 method 
 } 
 requests from 
 ${ 
 origin 
 } 
 sharing 
  
 ${ 
 responseHeader 
 } 
 responses across origins` 
 ); 
 } 
 configureBucketCors 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 );

    PHP

    For more information, see the Cloud Storage PHP API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      use Google\Cloud\Storage\StorageClient; 
 /** 
 * Update the CORS configuration of a bucket. 
 * 
 * @param string $bucketName The name of your Cloud Storage bucket. 
 *        (e.g. 'my-bucket') 
 * @param string $method The HTTP method for the CORS config. (e.g. 'GET') 
 * @param string $origin The origin from which the CORS config will allow requests. 
 *        (e.g. 'http://example.appspot.com') 
 * @param string $responseHeader The response header to share across origins. 
 *        (e.g. 'Content-Type') 
 * @param int $maxAgeSeconds The maximum amount of time the browser can make 
 *        (e.g. 3600) 
 *     requests before it must repeat preflighted requests. 
 */ 
 function cors_configuration(string $bucketName, string $method, string $origin, string $responseHeader, int $maxAgeSeconds): void 
 { 
 $storage = new StorageClient(); 
 $bucket = $storage->bucket($bucketName); 
 $bucket->update([ 
 'cors' => [ 
 [ 
 'method' => [$method], 
 'origin' => [$origin], 
 'responseHeader' => [$responseHeader], 
 'maxAgeSeconds' => $maxAgeSeconds, 
 ] 
 ] 
 ]); 
 printf( 
 'Bucket %s was updated with a CORS config to allow GET requests from ' . 
 '%s sharing %s responses across origins.', 
 $bucketName, 
 $origin, 
 $responseHeader 
 ); 
 }

    Python

    For more information, see the Cloud Storage Python API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      from 
  
 google.cloud 
  
 import 
  storage 
 
 def 
  
 cors_configuration 
 ( 
 bucket_name 
 ): 
  
 """Set a bucket's CORS policies configuration.""" 
 # bucket_name = "your-bucket-name" 
 storage_client 
 = 
  storage 
 
 . 
  Client 
 
 () 
 bucket 
 = 
 storage_client 
 . 
  get_bucket 
 
 ( 
 bucket_name 
 ) 
 bucket 
 . 
  cors 
 
 = 
 [ 
 { 
 "origin" 
 : 
 [ 
 "*" 
 ], 
 "responseHeader" 
 : 
 [ 
 "Content-Type" 
 , 
 "x-goog-resumable" 
 ], 
 "method" 
 : 
 [ 
 'PUT' 
 , 
 'POST' 
 ], 
 "maxAgeSeconds" 
 : 
 3600 
 } 
 ] 
 bucket 
 . 
 patch 
 () 
 print 
 ( 
 f 
 "Set CORS policies for bucket 
 { 
 bucket 
 . 
 name 
 } 
 is 
 { 
 bucket 
 . 
  cors 
 
 } 
 " 
 ) 
 return 
 bucket

    Ruby

    For more information, see the Cloud Storage Ruby API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample sets a CORS configuration on a bucket:

      def 
  
 cors_configuration 
  
 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 
 . 
 cors 
  
 do 
  
 | 
 c 
 | 
  
 c 
 . 
  add_rule 
 
  
 [ 
 "*" 
 ] 
 , 
  
 [ 
 "PUT" 
 , 
  
 "POST" 
 ] 
 , 
  
 headers 
 : 
  
 [ 
  
 "Content-Type" 
 , 
  
 "x-goog-resumable" 
  
 ] 
 , 
  
 max_age 
 : 
  
 3600 
  
 end 
  
 puts 
  
 "Set CORS policies for bucket 
 #{ 
 bucket_name 
 } 
 " 
 end

    Rust

    The following sample sets a CORS configuration on a bucket:

      use 
  
 google_cloud_storage 
 :: 
 client 
 :: 
 StorageControl 
 ; 
 use 
  
 google_cloud_storage 
 :: 
 model 
 :: 
 bucket 
 :: 
 Cors 
 ; 
 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 
  
 mut 
  
 cors 
  
 = 
  
 bucket 
 . 
 cors 
 . 
 clone 
 (); 
  
 cors 
 . 
 push 
 ( 
  
 Cors 
 :: 
 new 
 () 
  
 . 
 set_origin 
 ([ 
 "http://example.appspot.com" 
 . 
 to_string 
 ()]) 
  
 . 
 set_method 
 ([ 
 "GET" 
 . 
 to_string 
 (), 
  
 "HEAD" 
 . 
 to_string 
 (), 
  
 "DELETE" 
 . 
 to_string 
 ()]) 
  
 . 
 set_response_header 
 ([ 
 "Content-Type" 
 . 
 to_string 
 ()]) 
  
 . 
 set_max_age_seconds 
 ( 
 3600 
 ), 
  
 ); 
  
 let 
  
 bucket 
  
 = 
  
 client 
  
 . 
 update_bucket 
 () 
  
 . 
 set_bucket 
 ( 
 bucket 
 . 
 set_cors 
 ( 
 cors 
 )) 
  
 . 
 set_if_metageneration_match 
 ( 
 metageneration 
 ) 
  
 . 
 set_update_mask 
 ( 
 FieldMask 
 :: 
 default 
 (). 
 set_paths 
 ([ 
 "cors" 
 ])) 
  
 . 
 send 
 () 
  
 . 
 await 
 ? 
 ; 
  
 println! 
 ( 
 "successfully updated bucket CORS for {bucket_id}: {bucket:?}" 
 ); 
  
 Ok 
 (()) 
 }

    REST APIs

    JSON API

    1. Have gcloud CLI installed and initialized , which lets you generate an access token for the Authorization header.

    2. Create a JSON file with the CORS configuration you would like to apply. See configuration examples for sample JSON files.

    3. Use cURL to call the JSON API with a PATCH Bucket request:

       curl 
  
 -- 
 reques 
 t 
  
 PATCH 
  
 \ 
  
 'h 
 tt 
 ps 
 : 
 //storage.googleapis.com/storage/v1/b/ BUCKET_NAME 
?fields=cors' \ 
  
 -- 
 header 
  
 'Au 
 t 
 horiza 
 t 
 io 
 n 
 : 
  
 Bearer 
  
 $(gcloud 
  
 au 
 t 
 h 
  
 pri 
 nt 
 - 
 access 
 - 
 t 
 oke 
 n 
 )' 
  
 \ 
  
 -- 
 header 
  
 'Co 
 ntent 
 - 
 Type 
 : 
  
 applica 
 t 
 io 
 n 
 /jso 
 n 
 ' 
  
 \ 
  
 -- 
 da 
 ta 
 - 
 bi 
 nar 
 y 
  
 @ CORS_CONFIG_FILE

      Where:

      • BUCKET_NAME is the name of the bucket. For example, my-bucket .
      • CORS_CONFIG_FILE is the path to the JSON file you created in Step 2.

    XML API

    1. Have gcloud CLI installed and initialized , which lets you generate an access token for the Authorization header.

    2. Create an XML file with the CORS configuration you would like to apply. See configuration examples for sample XML files.

    3. Use cURL to call the XML API with a PUT Bucket request scoped to ?cors :

      curl  
-X  
PUT  
--data-binary  
@ CORS_CONFIG_FILE 
  
\
-H  
"Authorization:  
Bearer  
$(gcloud  
auth  
print-access-token)"  
\
-H  
"x-goog-project-id:  
 PROJECT_ID 
"  
\
"https://storage.googleapis.com/ BUCKET_NAME 
?cors"

      Where:

      • BUCKET_NAME is the name of the bucket. For example, my-bucket .
      • PROJECT_ID is the ID of the project associated with the bucket. For example, my-project .
      • CORS_CONFIG_FILE is the path to the XML file you created in Step 2.

    View the CORS configuration for a bucket

    Console

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

      Go to Buckets

    2. Click the name of the bucket.

    3. Click the Configurationtab.

    4. In the Cross-origin resource sharingsection, click Edit CORS configuration.

    5. Click the configuration.

    6. Optional: Edit the configuration, or click Cancelto close the dialog.

    Command line

    Use the gcloud storage buckets describe command with the --format flag:

    gcloud storage buckets describe gs:// BUCKET_NAME 
--format="default(cors_config)"

    Where BUCKET_NAME is the name of the bucket whose CORS configuration you want to view. For example, my-bucket .

    Client libraries

    To view the CORS configuration for a bucket using the client libraries, follow the instructions for displaying a bucket's metadata and look for the CORS field in the response:

    C++

    For more information, see the Cloud Storage C++ API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      namespace 
  
 gcs 
  
 = 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 storage 
 ; 
 using 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 StatusOr 
 ; 
 []( 
 gcs 
 :: 
 Client 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 bucket_name 
 ) 
  
 { 
  
 StatusOr<gcs 
 :: 
 BucketMetadata 
>  
 bucket_metadata 
  
 = 
  
 client 
 . 
 GetBucketMetadata 
 ( 
 bucket_name 
 ); 
  
 if 
  
 ( 
 ! 
 bucket_metadata 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 bucket_metadata 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "The metadata for bucket " 
 << 
 bucket_metadata 
 - 
> name 
 () 
 << 
 " is " 
 << 
 * 
 bucket_metadata 
 << 
 " 
 \n 
 " 
 ; 
 }

    C#

    For more information, see the Cloud Storage C# API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      using 
  
 Google.Apis.Storage.v1.Data 
 ; 
 using 
  
  Google.Cloud.Storage.V1 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 GetBucketMetadataSample 
 { 
  
 public 
  
 Bucket 
  
 GetBucketMetadata 
 ( 
 string 
  
 bucketName 
  
 = 
  
 "your-unique-bucket-name" 
 ) 
  
 { 
  
 var 
  
 storage 
  
 = 
  
  StorageClient 
 
 . 
  Create 
 
 (); 
  
 var 
  
 bucket 
  
 = 
  
 storage 
 . 
 GetBucket 
 ( 
 bucketName 
 , 
  
 new 
  
  GetBucketOptions 
 
  
 { 
  
 Projection 
  
 = 
  
  Projection 
 
 . 
  Full 
 
  
 }); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Bucket:\t{bucket.Name}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Acl:\t{bucket. Acl 
}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Billing:\t{bucket.Billing}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Cors:\t{bucket.Cors}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"DefaultEventBasedHold:\t{bucket.DefaultEventBasedHold}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"DefaultObjectAcl:\t{bucket.DefaultObjectAcl}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Encryption:\t{bucket.Encryption}" 
 ); 
  
 if 
  
 ( 
 bucket 
 . 
 Encryption 
  
 != 
  
 null 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"KmsKeyName:\t{bucket.Encryption.DefaultKmsKeyName}" 
 ); 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Id:\t{bucket.Id}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Kind:\t{bucket.Kind}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Lifecycle:\t{bucket.Lifecycle}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Location:\t{bucket.Location}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"LocationType:\t{bucket.LocationType}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Logging:\t{bucket.Logging}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Metageneration:\t{bucket.Metageneration}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"ObjectRetention:\t{bucket.ObjectRetention}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Owner:\t{bucket.Owner}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"ProjectNumber:\t{bucket.ProjectNumber}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"RetentionPolicy:\t{bucket.RetentionPolicy}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"SelfLink:\t{bucket.SelfLink}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"StorageClass:\t{bucket.StorageClass}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"TimeCreated:\t{bucket.TimeCreated}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Updated:\t{bucket.Updated}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Versioning:\t{bucket.Versioning}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Website:\t{bucket.Website}" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"TurboReplication:\t{bucket.Rpo}" 
 ); 
  
 if 
  
 ( 
 bucket 
 . 
 Labels 
  
 != 
  
 null 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 "Labels:" 
 ); 
  
 foreach 
  
 ( 
 var 
  
 label 
  
 in 
  
 bucket 
 . 
 Labels 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"{label. Key 
}:\t{label.Value}" 
 ); 
  
 } 
  
 } 
  
 return 
  
 bucket 
 ; 
  
 } 
 }

    Go

    For more information, see the Cloud Storage Go API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "time" 
  
 "cloud.google.com/go/storage" 
 ) 
 // getBucketMetadata gets the bucket metadata. 
 func 
  
 getBucketMetadata 
 ( 
 w 
  
 io 
 . 
  Writer 
 
 , 
  
 bucketName 
  
 string 
 ) 
  
 ( 
 * 
 storage 
 . 
  BucketAttrs 
 
 , 
  
 error 
 ) 
  
 { 
  
 // bucketName := "bucket-name" 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 client 
 , 
  
 err 
  
 := 
  
 storage 
 . 
 NewClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 nil 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "storage.NewClient: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 defer 
  
 client 
 . 
 Close 
 () 
  
 ctx 
 , 
  
 cancel 
  
 := 
  
 context 
 . 
 WithTimeout 
 ( 
 ctx 
 , 
  
 time 
 . 
 Second 
 * 
 10 
 ) 
  
 defer 
  
 cancel 
 () 
  
 attrs 
 , 
  
 err 
  
 := 
  
 client 
 . 
  Bucket 
 
 ( 
 bucketName 
 ). 
 Attrs 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 nil 
 , 
  
 fmt 
 . 
 Errorf 
 ( 
 "Bucket(%q).Attrs: %w" 
 , 
  
 bucketName 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "BucketName: %v\n" 
 , 
  
 attrs 
 . 
 Name 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Location: %v\n" 
 , 
  
 attrs 
 . 
 Location 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "LocationType: %v\n" 
 , 
  
 attrs 
 . 
 LocationType 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "StorageClass: %v\n" 
 , 
  
 attrs 
 . 
 StorageClass 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Turbo replication (RPO): %v\n" 
 , 
  
 attrs 
 . 
  RPO 
 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "TimeCreated: %v\n" 
 , 
  
 attrs 
 . 
 Created 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Metageneration: %v\n" 
 , 
  
 attrs 
 . 
 MetaGeneration 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "PredefinedACL: %v\n" 
 , 
  
 attrs 
 . 
 PredefinedACL 
 ) 
  
 if 
  
 attrs 
 . 
 Encryption 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "DefaultKmsKeyName: %v\n" 
 , 
  
 attrs 
 . 
 Encryption 
 . 
 DefaultKMSKeyName 
 ) 
  
 } 
  
 if 
  
 attrs 
 . 
 Website 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "IndexPage: %v\n" 
 , 
  
 attrs 
 . 
 Website 
 . 
 MainPageSuffix 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "NotFoundPage: %v\n" 
 , 
  
 attrs 
 . 
 Website 
 . 
 NotFoundPage 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "DefaultEventBasedHold: %v\n" 
 , 
  
 attrs 
 . 
 DefaultEventBasedHold 
 ) 
  
 if 
  
 attrs 
 . 
  RetentionPolicy 
 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "RetentionEffectiveTime: %v\n" 
 , 
  
 attrs 
 . 
  RetentionPolicy 
 
 . 
 EffectiveTime 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "RetentionPeriod: %v\n" 
 , 
  
 attrs 
 . 
  RetentionPolicy 
 
 . 
 RetentionPeriod 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "RetentionPolicyIsLocked: %v\n" 
 , 
  
 attrs 
 . 
  RetentionPolicy 
 
 . 
 IsLocked 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "ObjectRetentionMode: %v\n" 
 , 
  
 attrs 
 . 
 ObjectRetentionMode 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "RequesterPays: %v\n" 
 , 
  
 attrs 
 . 
 RequesterPays 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "VersioningEnabled: %v\n" 
 , 
  
 attrs 
 . 
 VersioningEnabled 
 ) 
  
 if 
  
 attrs 
 . 
 Logging 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "LogBucket: %v\n" 
 , 
  
 attrs 
 . 
 Logging 
 . 
 LogBucket 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "LogObjectPrefix: %v\n" 
 , 
  
 attrs 
 . 
 Logging 
 . 
 LogObjectPrefix 
 ) 
  
 } 
  
 if 
  
 attrs 
 . 
  CORS 
 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintln 
 ( 
 w 
 , 
  
 "CORS:" 
 ) 
  
 for 
  
 _ 
 , 
  
 v 
  
 := 
  
 range 
  
 attrs 
 . 
  CORS 
 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\tMaxAge: %v\n" 
 , 
  
 v 
 . 
 MaxAge 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\tMethods: %v\n" 
 , 
  
 v 
 . 
 Methods 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\tOrigins: %v\n" 
 , 
  
 v 
 . 
 Origins 
 ) 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\tResponseHeaders: %v\n" 
 , 
  
 v 
 . 
 ResponseHeaders 
 ) 
  
 } 
  
 } 
  
 if 
  
 attrs 
 . 
 Labels 
  
 != 
  
 nil 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\n\n\nLabels:" 
 ) 
  
 for 
  
 key 
 , 
  
 value 
  
 := 
  
 range 
  
 attrs 
 . 
 Labels 
  
 { 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "\t%v = %v\n" 
 , 
  
 key 
 , 
  
 value 
 ) 
  
 } 
  
 } 
  
 return 
  
 attrs 
 , 
  
 nil 
 }

    Java

    For more information, see the Cloud Storage Java API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      import 
  
 com.google.cloud.storage. Bucket 
 
 ; 
 import 
  
 com.google.cloud.storage. BucketInfo 
 
 ; 
 import 
  
 com.google.cloud.storage. Storage 
 
 ; 
 import 
  
 com.google.cloud.storage. StorageOptions 
 
 ; 
 import 
  
 java.util.Map 
 ; 
 public 
  
 class 
 GetBucketMetadata 
  
 { 
  
 public 
  
 static 
  
 void 
  
 getBucketMetadata 
 ( 
 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"; 
  
  Storage 
 
  
 storage 
  
 = 
  
  StorageOptions 
 
 . 
 newBuilder 
 (). 
 setProjectId 
 ( 
 projectId 
 ). 
 build 
 (). 
  getService 
 
 (); 
  
 // Select all fields. Fields can be selected individually e.g. Storage.BucketField.NAME 
  
  Bucket 
 
  
 bucket 
  
 = 
  
 storage 
 . 
  get 
 
 ( 
 bucketName 
 , 
  
 Storage 
 . 
 BucketGetOption 
 . 
 fields 
 ( 
 Storage 
 . 
 BucketField 
 . 
 values 
 ())); 
  
 // Print bucket metadata 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "BucketName: " 
  
 + 
  
 bucket 
 . 
 getName 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "DefaultEventBasedHold: " 
  
 + 
  
 bucket 
 . 
  getDefaultEventBasedHold 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "DefaultKmsKeyName: " 
  
 + 
  
 bucket 
 . 
  getDefaultKmsKeyName 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Id: " 
  
 + 
  
 bucket 
 . 
 getGeneratedId 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "IndexPage: " 
  
 + 
  
 bucket 
 . 
  getIndexPage 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Location: " 
  
 + 
  
 bucket 
 . 
 getLocation 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "LocationType: " 
  
 + 
  
 bucket 
 . 
  getLocationType 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Metageneration: " 
  
 + 
  
 bucket 
 . 
 getMetageneration 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "NotFoundPage: " 
  
 + 
  
 bucket 
 . 
  getNotFoundPage 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "RetentionEffectiveTime: " 
  
 + 
  
 bucket 
 . 
  getRetentionEffectiveTime 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "RetentionPeriod: " 
  
 + 
  
 bucket 
 . 
  getRetentionPeriod 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "RetentionPolicyIsLocked: " 
  
 + 
  
 bucket 
 . 
  retentionPolicyIsLocked 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "RequesterPays: " 
  
 + 
  
 bucket 
 . 
 requesterPays 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "SelfLink: " 
  
 + 
  
 bucket 
 . 
 getSelfLink 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "StorageClass: " 
  
 + 
  
 bucket 
 . 
 getStorageClass 
 (). 
  name 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "TimeCreated: " 
  
 + 
  
 bucket 
 . 
 getCreateTime 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "VersioningEnabled: " 
  
 + 
  
 bucket 
 . 
  versioningEnabled 
 
 ()); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "ObjectRetention: " 
  
 + 
  
 bucket 
 . 
 getObjectRetention 
 ()); 
  
 if 
  
 ( 
 bucket 
 . 
 getLabels 
 () 
  
 != 
  
 null 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "\n\n\nLabels:" 
 ); 
  
 for 
  
 ( 
 Map 
 . 
 Entry<String 
 , 
  
 String 
>  
 label 
  
 : 
  
 bucket 
 . 
 getLabels 
 (). 
 entrySet 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 label 
 . 
 getKey 
 () 
  
 + 
  
 "=" 
  
 + 
  
 label 
 . 
 getValue 
 ()); 
  
 } 
  
 } 
  
 if 
  
 ( 
 bucket 
 . 
 getLifecycleRules 
 () 
  
 != 
  
 null 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "\n\n\nLifecycle Rules:" 
 ); 
  
 for 
  
 ( 
 BucketInfo 
 . 
 LifecycleRule 
  
 rule 
  
 : 
  
 bucket 
 . 
 getLifecycleRules 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 rule 
 ); 
  
 } 
  
 } 
  
 } 
 }

    Node.js

    For more information, see the Cloud Storage Node.js API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      // Imports the Google Cloud client library 
 const 
  
 { 
 Storage 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/storage 
' 
 ); 
 // Creates a client 
 const 
  
 storage 
  
 = 
  
 new 
  
  Storage 
 
 (); 
 async 
  
 function 
  
 getBucketMetadata 
 () 
  
 { 
  
 /** 
 * TODO(developer): Uncomment the following lines before running the sample. 
 */ 
  
 // The ID of your GCS bucket 
  
 // const bucketName = 'your-unique-bucket-name'; 
  
 // Get Bucket Metadata 
  
 const 
  
 [ 
 metadata 
 ] 
  
 = 
  
 await 
  
 storage 
 . 
 bucket 
 ( 
 bucketName 
 ). 
 getMetadata 
 (); 
  
 console 
 . 
 log 
 ( 
  JSON 
 
 . 
 stringify 
 ( 
 metadata 
 , 
  
 null 
 , 
  
 2 
 )); 
 }

    PHP

    For more information, see the Cloud Storage PHP API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      use Google\Cloud\Storage\StorageClient; 
 /** 
 * Get bucket metadata. 
 * 
 * @param string $bucketName The name of your Cloud Storage bucket. 
 *        (e.g. 'my-bucket') 
 */ 
 function get_bucket_metadata(string $bucketName): void 
 { 
 $storage = new StorageClient(); 
 $bucket = $storage->bucket($bucketName); 
 $info = $bucket->info(); 
 printf('Bucket Metadata: %s' . PHP_EOL, print_r($info, true)); 
 }

    Python

    For more information, see the Cloud Storage Python API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      from 
  
 google.cloud 
  
 import 
  storage 
 
 def 
  
 bucket_metadata 
 ( 
 bucket_name 
 ): 
  
 """Prints out a bucket's metadata.""" 
 # bucket_name = 'your-bucket-name' 
 storage_client 
 = 
  storage 
 
 . 
  Client 
 
 () 
 bucket 
 = 
 storage_client 
 . 
  get_bucket 
 
 ( 
 bucket_name 
 ) 
 print 
 ( 
 f 
 "ID: 
 { 
 bucket 
 . 
 id 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Name: 
 { 
 bucket 
 . 
 name 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Storage Class: 
 { 
 bucket 
 . 
 storage_class 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Location: 
 { 
 bucket 
 . 
  location 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Location Type: 
 { 
 bucket 
 . 
  location_type 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Cors: 
 { 
 bucket 
 . 
  cors 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Default Event Based Hold: 
 { 
 bucket 
 . 
  default_event_based_hold 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Default KMS Key Name: 
 { 
 bucket 
 . 
 default_kms_key_name 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Metageneration: 
 { 
 bucket 
 . 
 metageneration 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Public Access Prevention: 
 { 
 bucket 
 . 
  iam_configuration 
 
 . 
  public_access_prevention 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Retention Effective Time: 
 { 
 bucket 
 . 
  retention_policy_effective_time 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Retention Period: 
 { 
 bucket 
 . 
  retention_period 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Retention Policy Locked: 
 { 
 bucket 
 . 
  retention_policy_locked 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Object Retention Mode: 
 { 
 bucket 
 . 
  object_retention_mode 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Requester Pays: 
 { 
 bucket 
 . 
  requester_pays 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Self Link: 
 { 
 bucket 
 . 
 self_link 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Time Created: 
 { 
 bucket 
 . 
 time_created 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Versioning Enabled: 
 { 
 bucket 
 . 
  versioning_enabled 
 
 } 
 " 
 ) 
 print 
 ( 
 f 
 "Labels: 
 { 
 bucket 
 . 
  labels 
 
 } 
 " 
 )

    Ruby

    For more information, see the Cloud Storage Ruby API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

      def 
  
 get_bucket_metadata 
  
 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 
  
 puts 
  
 "ID: 
 #{ 
 bucket 
 . 
 id 
 } 
 " 
  
 puts 
  
 "Name: 
 #{ 
 bucket 
 . 
 name 
 } 
 " 
  
 puts 
  
 "Storage Class: 
 #{ 
 bucket 
 . 
 storage_class 
 } 
 " 
  
 puts 
  
 "Location: 
 #{ 
 bucket 
 . 
 location 
 } 
 " 
  
 puts 
  
 "Location Type: 
 #{ 
 bucket 
 . 
 location_type 
 } 
 " 
  
 puts 
  
 "Cors: 
 #{ 
 bucket 
 . 
 cors 
 } 
 " 
  
 puts 
  
 "Default Event Based Hold: 
 #{ 
 bucket 
 . 
  default_event_based_hold? 
 
 } 
 " 
  
 puts 
  
 "Default KMS Key Name: 
 #{ 
 bucket 
 . 
  default_kms_key 
 
 } 
 " 
  
 puts 
  
 "Logging Bucket: 
 #{ 
 bucket 
 . 
  logging_bucket 
 
 } 
 " 
  
 puts 
  
 "Logging Prefix: 
 #{ 
 bucket 
 . 
  logging_prefix 
 
 } 
 " 
  
 puts 
  
 "Metageneration: 
 #{ 
 bucket 
 . 
 metageneration 
 } 
 " 
  
 puts 
  
 "Retention Effective Time: 
 #{ 
 bucket 
 . 
  retention_effective_at 
 
 } 
 " 
  
 puts 
  
 "Retention Period: 
 #{ 
 bucket 
 . 
  retention_period 
 
 } 
 " 
  
 puts 
  
 "Retention Policy Locked: 
 #{ 
 bucket 
 . 
  retention_policy_locked? 
 
 } 
 " 
  
 puts 
  
 "Requester Pays: 
 #{ 
 bucket 
 . 
  requester_pays 
 
 } 
 " 
  
 puts 
  
 "Self Link: 
 #{ 
 bucket 
 . 
 api_url 
 } 
 " 
  
 puts 
  
 "Time Created: 
 #{ 
 bucket 
 . 
 created_at 
 } 
 " 
  
 puts 
  
 "Versioning Enabled: 
 #{ 
 bucket 
 . 
  versioning? 
 
 } 
 " 
  
 puts 
  
 "Index Page: 
 #{ 
 bucket 
 . 
  website_main 
 
 } 
 " 
  
 puts 
  
 "Not Found Page: 
 #{ 
 bucket 
 . 
  website_404 
 
 } 
 " 
  
 puts 
  
 "Labels:" 
  
 bucket 
 . 
 labels 
 . 
  each 
 
  
 do 
  
 | 
 key 
 , 
  
 value 
 | 
  
 puts 
  
 " - 
 #{ 
 key 
 } 
 = 
 #{ 
 value 
 } 
 " 
  
 end 
  
 puts 
  
 "Lifecycle Rules:" 
  
 bucket 
 . 
 lifecycle 
 . 
  each 
 
  
 do 
  
 | 
 rule 
 | 
  
 puts 
  
 " 
 #{ 
 rule 
 . 
  action 
 
 } 
 - 
 #{ 
 rule 
 . 
 storage_class 
 } 
 - 
 #{ 
 rule 
 . 
  age 
 
 } 
 - 
 #{ 
 rule 
 . 
  matches_storage_class 
 
 } 
 " 
  
 end 
 end

    Rust 

      use 
  
 google_cloud_storage 
 :: 
 client 
 :: 
 StorageControl 
 ; 
 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 
 ? 
 ; 
  
 println! 
 ( 
 "successfully obtained bucket metadata {bucket:?}" 
 ); 
  
 Ok 
 (()) 
 }

    REST APIs

    JSON API

    1. Have gcloud CLI installed and initialized , which lets you generate an access token for the Authorization header.

    2. Use cURL to call the JSON API with a GET Bucket request:

       curl 
  
 - 
 X 
  
 GET 
  
 \ 
  
 - 
 H 
  
 "Authorization: Bearer $(gcloud auth print-access-token)" 
  
 \ 
  
 "https://storage.googleapis.com/storage/v1/b/ BUCKET_NAME 
?fields=cors"

      Where BUCKET_NAME is the name of the bucket whose CORS configuration you want to view. For example, my-bucket .

    XML API

    1. Have gcloud CLI installed and initialized , which lets you generate an access token for the Authorization header.

    2. Use cURL to call the XML API with a GET Bucket request scoped to ?cors :

      curl  
-X  
GET  
\  
-H  
"Authorization:  
Bearer  
$(gcloud  
auth  
print-access-token)"  
\  
"https://storage.googleapis.com/ BUCKET_NAME 
?cors"

      Where BUCKET_NAME is the name of the bucket whose CORS configuration you want to view. For example, my-bucket .

    Remove the CORS configuration from a bucket

    Console

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

      Go to Buckets

    2. Click the name of the bucket.

    3. Click the Configurationtab.

    4. In the Cross-origin resource sharingsection, click Edit CORS configuration.

    5. Do either of the following things:

      • To delete a specific CORS configuration, click Deletefor the configuration that you want to remove.

      • To turn off CORS and delete all CORS configurations for the bucket, clear the Allow cross-origin resource sharingcheckbox.

    6. Click Save.

    Command line

    To remove the CORS configuration from a bucket, use the gcloud storage buckets update command with the --clear-cors flag:

    gcloud storage buckets update gs:// BUCKET_NAME 
--clear-cors

    Replace BUCKET_NAME with the name of the bucket whose CORS configuration you want to remove.

    Client libraries

    C++

    For more information, see the Cloud Storage C++ API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      namespace 
  
 gcs 
  
 = 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 storage 
 ; 
 using 
  
 :: 
 google 
 :: 
 cloud 
 :: 
 StatusOr 
 ; 
 []( 
 gcs 
 :: 
 Client 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 bucket_name 
 ) 
  
 { 
  
 StatusOr<gcs 
 :: 
 BucketMetadata 
>  
 original 
  
 = 
  
 client 
 . 
 GetBucketMetadata 
 ( 
 bucket_name 
 ); 
  
 if 
  
 ( 
 ! 
 original 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 original 
 ). 
 status 
 (); 
  
 StatusOr<gcs 
 :: 
 BucketMetadata 
>  
 patched 
  
 = 
  
 client 
 . 
 PatchBucket 
 ( 
  
 bucket_name 
 , 
  
 gcs 
 :: 
 BucketMetadataPatchBuilder 
 (). 
 ResetCors 
 (), 
  
 gcs 
 :: 
 IfMetagenerationMatch 
 ( 
 original 
 - 
> metageneration 
 ())); 
  
 if 
  
 ( 
 ! 
 patched 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 patched 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "Cors configuration successfully removed for bucket " 
 << 
 patched 
 - 
> name 
 () 
 << 
 " 
 \n 
 " 
 ; 
 }

    C#

    For more information, see the Cloud Storage C# API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      using 
  
 Google.Apis.Storage.v1.Data 
 ; 
 using 
  
  Google.Cloud.Storage.V1 
 
 ; 
 using 
  
 System 
 ; 
 public 
  
 class 
  
 BucketRemoveCorsConfigurationSample 
 { 
  
 public 
  
 Bucket 
  
 BucketRemoveCorsConfiguration 
 ( 
 string 
  
 bucketName 
  
 = 
  
 "your-bucket-name" 
 ) 
  
 { 
  
 var 
  
 storage 
  
 = 
  
  StorageClient 
 
 . 
  Create 
 
 (); 
  
 var 
  
 bucket 
  
 = 
  
 storage 
 . 
 GetBucket 
 ( 
 bucketName 
 ); 
  
 if 
  
 ( 
 bucket 
 . 
 Cors 
  
 == 
  
 null 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 "No CORS to remove" 
 ); 
  
 } 
  
 else 
  
 { 
  
 bucket 
 . 
 Cors 
  
 = 
  
 null 
 ; 
  
 bucket 
  
 = 
  
 storage 
 . 
 UpdateBucket 
 ( 
 bucket 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Removed CORS configuration from bucket {bucketName}." 
 ); 
  
 } 
  
 return 
  
 bucket 
 ; 
  
 } 
 }

    Go

    For more information, see the Cloud Storage Go API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      import 
  
 ( 
  
 "context" 
  
 "fmt" 
  
 "io" 
  
 "time" 
  
 "cloud.google.com/go/storage" 
 ) 
 // removeBucketCORSConfiguration removes the CORS configuration from a bucket. 
 func 
  
 removeBucketCORSConfiguration 
 ( 
 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 
 ) 
  
 bucketAttrsToUpdate 
  
 := 
  
 storage 
 . 
  BucketAttrsToUpdate 
 
 { 
  
 CORS 
 : 
  
 [] 
 storage 
 . 
  CORS 
 
 {}, 
  
 } 
  
 if 
  
 _ 
 , 
  
 err 
  
 := 
  
 bucket 
 . 
 Update 
 ( 
 ctx 
 , 
  
 bucketAttrsToUpdate 
 ); 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "Bucket(%q).Update: %w" 
 , 
  
 bucketName 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Removed CORS configuration from a bucket %v\n" 
 , 
  
 bucketName 
 ) 
  
 return 
  
 nil 
 }

    Java

    For more information, see the Cloud Storage Java API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      import 
  
 com.google.cloud.storage. Bucket 
 
 ; 
 import 
  
 com.google.cloud.storage. Cors 
 
 ; 
 import 
  
 com.google.cloud.storage. Storage 
 
 ; 
 import 
  
 com.google.cloud.storage. StorageOptions 
 
 ; 
 import 
  
 java.util.ArrayList 
 ; 
 import 
  
 java.util.List 
 ; 
 public 
  
 class 
 RemoveBucketCors 
  
 { 
  
 public 
  
 static 
  
 void 
  
 removeBucketCors 
 ( 
 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"; 
  
  Storage 
 
  
 storage 
  
 = 
  
  StorageOptions 
 
 . 
 newBuilder 
 (). 
 setProjectId 
 ( 
 projectId 
 ). 
 build 
 (). 
  getService 
 
 (); 
  
  Bucket 
 
  
 bucket 
  
 = 
  
 storage 
 . 
  get 
 
 ( 
 bucketName 
 , 
  
 Storage 
 . 
 BucketGetOption 
 . 
 fields 
 ( 
 Storage 
 . 
 BucketField 
 . 
 CORS 
 )); 
  
 // getCors() returns the List and copying over to an ArrayList so it's mutable. 
  
 List<Cors> 
  
 cors 
  
 = 
  
 new 
  
 ArrayList 
<> ( 
 bucket 
 . 
  getCors 
 
 ()); 
  
 // Clear bucket CORS configuration. 
  
 cors 
 . 
 clear 
 (); 
  
 // Update bucket to remove CORS. 
  
 bucket 
 . 
  toBuilder 
 
 (). 
 setCors 
 ( 
 cors 
 ). 
 build 
 (). 
 update 
 (); 
  
 System 
 . 
 out 
 . 
 println 
 ( 
 "Removed CORS configuration from bucket " 
  
 + 
  
 bucketName 
 ); 
  
 } 
 }

    Node.js

    For more information, see the Cloud Storage Node.js API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      /** 
 * TODO(developer): Uncomment the following lines before running the sample. 
 */ 
 // The ID of your GCS bucket 
 // const bucketName = 'your-unique-bucket-name'; 
 // Imports the Google Cloud client library 
 const 
  
 { 
 Storage 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/storage 
' 
 ); 
 // Creates a client 
 const 
  
 storage 
  
 = 
  
 new 
  
  Storage 
 
 (); 
 async 
  
 function 
  
 removeBucketCors 
 () 
  
 { 
  
 await 
  
 storage 
 . 
 bucket 
 ( 
 bucketName 
 ). 
  setCorsConfiguration 
 
 ([]); 
  
 console 
 . 
 log 
 ( 
 `Removed CORS configuration from bucket 
 ${ 
 bucketName 
 } 
 ` 
 ); 
 } 
 removeBucketCors 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 );

    PHP

    For more information, see the Cloud Storage PHP API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      use Google\Cloud\Storage\StorageClient; 
 /** 
 * Remove the CORS configuration from the specified bucket. 
 * 
 * @param string $bucketName The name of your Cloud Storage bucket. 
 *        (e.g. 'my-bucket') 
 */ 
 function remove_cors_configuration(string $bucketName): void 
 { 
 $storage = new StorageClient(); 
 $bucket = $storage->bucket($bucketName); 
 $bucket->update([ 
 'cors' => null, 
 ]); 
 printf('Removed CORS configuration from bucket %s', $bucketName); 
 }

    Python

    For more information, see the Cloud Storage Python API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      from 
  
 google.cloud 
  
 import 
  storage 
 
 def 
  
 remove_cors_configuration 
 ( 
 bucket_name 
 ): 
  
 """Remove a bucket's CORS policies configuration.""" 
 # bucket_name = "your-bucket-name" 
 storage_client 
 = 
  storage 
 
 . 
  Client 
 
 () 
 bucket 
 = 
 storage_client 
 . 
  get_bucket 
 
 ( 
 bucket_name 
 ) 
 bucket 
 . 
  cors 
 
 = 
 [] 
 bucket 
 . 
 patch 
 () 
 print 
 ( 
 f 
 "Remove CORS policies for bucket 
 { 
 bucket 
 . 
 name 
 } 
 ." 
 ) 
 return 
 bucket

    Ruby

    For more information, see the Cloud Storage Ruby API reference documentation .

    To authenticate to Cloud Storage, set up Application Default Credentials. For more information, see Set up authentication for client libraries .

    The following sample removes any existing CORS configuration from a bucket:

      def 
  
 remove_cors_configuration 
  
 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 
 . 
 cors 
  
 do 
  
 | 
 c 
 | 
  
 c 
 . 
 clear 
  
 end 
  
 puts 
  
 "Remove CORS policies for bucket 
 #{ 
 bucket_name 
 } 
 " 
 end

    Rust

    The following sample removes any existing CORS configuration from a bucket:

      use 
  
 google_cloud_storage 
 :: 
 client 
 :: 
 StorageControl 
 ; 
 use 
  
 google_cloud_storage 
 :: 
 model 
 :: 
 bucket 
 :: 
 Cors 
 ; 
 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_cors 
 ( 
 Vec 
 :: 
< Cors 
> :: 
 new 
 ())) 
  
 . 
 set_if_metageneration_match 
 ( 
 metageneration 
 ) 
  
 . 
 set_update_mask 
 ( 
 FieldMask 
 :: 
 default 
 (). 
 set_paths 
 ([ 
 "cors" 
 ])) 
  
 . 
 send 
 () 
  
 . 
 await 
 ? 
 ; 
  
 println! 
 ( 
  
 "successfully removed CORS rule for bucket {bucket_id}: {:?}" 
 , 
  
 bucket 
 . 
 cors 
  
 ); 
  
 Ok 
 (()) 
 }

    REST APIs

    JSON API

    To remove all CORS settings from a bucket, set an empty CORS configuration on the bucket.

     { 
  
 "cors" 
 : 
  
 [] 
 }

    XML API

    To remove all CORS settings from a bucket, set an empty CORS configuration on the bucket.

    <CorsConfig></CorsConfig>

    What's next

    Create a Mobile Website
    View Site in Mobile | Classic
    Share by: