b2_create_bucket

Creates a new bucket. A bucket belongs to the account used to create it.

Buckets can be named. The name must be globally unique. No account can use a bucket with the same name. Buckets are assigned a unique bucketId which is used when uploading, downloading, or deleting files.

There is a limit of 100 buckets per account.

Request

Request HTTP Headers

Authorization

required

An account authorization token, obtained from b2_authorize_account.

Request HTTP Message Body Parameters

accountId

required

Your account ID.

bucketName

required

The name to give the new bucket.

Bucket names must be a minimum of 6 and a maximum of 50 characters long, and must be globally unique; two different B2 accounts cannot have buckets with the name name. Bucket names can consist of: letters, digits, and "-". Bucket names cannot start with "b2-"; these are reserved for internal Backblaze use.

bucketType

required

Either "allPublic", meaning that files in this bucket can be downloaded by anybody, or "allPrivate", meaning that you need a bucket authorization token to download the files.

bucketInfo

optional

User-defined information to be stored with the bucket: a JSON object mapping names to values. See Buckets.
Cache-Control policies can be set here on a global level for all the files in the bucket.

corsRules

optional

The initial list (a JSON array) of CORS rules for this bucket. See CORS Rules for an overview and the rule structure.

lifecycleRules

optional

The initial list (a JSON array) of lifecycle rules for this bucket. Structure defined below. See Lifecycle Rules.

Lifecycle Rule Structure

daysFromUploadingToHiding

optional

After a file is uploaded, the number of days before it can be hidden.

daysFromHidingToDeleting

optional

After a file is hidden, the number of days before it can be deleted.

fileNamePrefix

optional

The rule applies to files whose names start with this prefix.

Response

Response HTTP Status 200

Bucket successfully created. The JSON response will contain:

accountId

The account that the bucket is in.

bucketId

The unique ID of the bucket.

bucketName

The unique name of the bucket

bucketType

One of: "allPublic", "allPrivate", "snapshot", or other values added in the future. "allPublic" means that anybody can download the files is the bucket; "allPrivate" means that you need an authorization token to download them; "snapshot" means that it's a private bucket containing snapshots created on the B2 web site.

bucketInfo

The user data stored with this bucket.

lifecycleRules

The list of lifecycle rules for this bucket.

revision

A counter that is updated every time the bucket is modified, and can be used with the ifRevisionIs parameter to b2_update_bucket to prevent colliding, simultaneous updates.

Response Errors

Bucket not created. If possible the server will return a JSON error structure. Errors include:

status

code

message

400

bad_request

AccountId bad

400

bad_request

Account <accountId> does not exist

400

too_many_buckets

The account is already at the maximum bucket count

400

bad_request

bucketName is required

400

bad_request

bucketName must be at least 6 characters long

400

bad_request

bucketName can be at most 50 characters long

400

bad_request

Invalid characters in bucketName: must be alphanumeric or '-'

400

duplicate_bucket_name

Bucket name is already in use.

400

bad_request

No Authorization header

401

unauthorized

Not authorized

Sample Code

Code

ACCOUNT_ID=... # Comes from your account page on the Backblaze web site
ACCOUNT_AUTHORIZATION_TOKEN=... # Comes from the b2_authorize_account call
API_URL=... # Comes from the b2_authorize_account call
BUCKET_NAME=any-name-you-pick # 50 char max: letters, digits, “-“
BUCKET_TYPE=allPrivate # Either allPublic or allPrivate

curl -H "Authorization: $ACCOUNT_AUTHORIZATION_TOKEN" \
    "$API_URL/b2api/v1/b2_create_bucket?accountId=$ACCOUNT_ID&bucketName=$BUCKET_NAME&bucketType=$BUCKET_TYPE"

# NOTE: This example uses GET for the sake of brevity.  A curl example using the POST method is shown below. 
#       You will need to replace the bracketed values with your accountId, bucketName, and bucketType

curl -H  "Authorization: $ACCOUNT_AUTHORIZATION_TOKEN" \
	--data '{accountId:"<ACCOUNT_ID>",bucketName:"<BUCKET_NAME>",bucketType:"<BUCKET_TYPE>"}' \
	"$API_URL/b2api/v1/b2_create_bucket"

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}

Code

import java.io.*;
import java.util.*;
import java.net.HttpURLConnection;
import java.net.URL;

String apiUrl = ""; // Provided by b2_authorize_account
String accountId = ""; // Obtained from your B2 account page.
String accountAuthorizationToken = "";  // Provided by b2_authorize_account
String bucketName = ""; // Name of the bucket you want to create
String bucketType = ""; // Either "allPublic" or "allPrivate"
HttpURLConnection connection = null;

try {
    URL url = new URL(apiUrl + "/b2api/v1/b2_create_bucket");
    connection = (HttpURLConnection)url.openConnection();
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Authorization", accountAuthorizationToken);
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
    connection.setRequestProperty("charset", "utf-8");
    connection.setRequestProperty("Content-Length", Integer.toString(postData.length));
    connection.setDoOutput(true);
    DataOutputStream writer = new DataOutputStream(connection.getOutputStream());
    writer.write("{\"accountId\":\"" + accountId + "\",\"bucketName\":\"" + bucketName + "\",\"bucketType\":\"" + bucketType + "\"}".getBytes(StandardCharsets.UTF_8));
    String jsonResponse = myInputStreamReader(connection.getInputStream());
    System.out.println(jsonResponse);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    connection.disconnect();
}

static public String myInputStreamReader(InputStream in) throws IOException {
    InputStreamReader reader = new InputStreamReader(in);
    StringBuilder sb = new StringBuilder();
    int c = reader.read();
    while (c != -1) {
        sb.append((char)c);
        c = reader.read();
    }
    reader.close();
    return sb.toString();
}

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}

Code

import json
import urllib2

ACCOUNT_ID = "..." # Comes from your account page on the Backblaze web site
ACCOUNT_AUTHORIZATION_TOKEN = "..." # Comes from the b2_authorize_account call
API_URL = "..." # Comes from the b2_authorize_account call
BUCKET_NAME = "any-name-you-pick" # 50 char max: letters, digits, “-“
BUCKET_TYPE = "allPrivate" # Either allPublic or allPrivate

url = API_URL + '/b2api/v1/b2_create_bucket'
params = {
    'accountId': ACCOUNT_ID,
    'bucketName': BUCKET_NAME,
    'bucketType': BUCKET_TYPE
    }
headers = {
    'Authorization': ACCOUNT_AUTHORIZATION_TOKEN
    }

request = urllib2.Request(url, json.dumps(params), headers)
response = urllib2.urlopen(request)
response_data = json.loads(response.read())
response.close()

print 'bucket id:', response['bucketId']


Output

bucket id: 4a48fe8875c6214145260818

Code

import Foundation

let apiUrl = "" // Provided by b2_authorize_account
let accountAuthorizationToken = "" // Provided by b2_authorize_account
let accountId = "" // B2 Cloud Storage Account ID
let bucketName = "" // Name of the bucket you want to create
let bucketType = "" // Either "allPublic" or "allPrivate"
let session = NSURLSession.sharedSession()
let request = NSMutableURLRequest(URL:NSURL(string: "\(apiUrl)")!.URLByAppendingPathComponent("/b2api/v1/b2_create_bucket"))
request.HTTPMethod = "POST"
request.addValue(accountAuthorizationToken, forHTTPHeaderField: "Authorization")
request.HTTPBody = "{\"accountId\":\"\(accountId)\", \"bucketName\":\"\(bucketName)\", \"bucketType\":\"\(bucketType)\"".dataUsingEncoding(NSUTF8StringEncoding)
let task = session.dataTaskWithRequest(request, completionHandler:{ (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void in
    if data != nil {
        let json = NSString(data: data, encoding:NSUTF8StringEncoding)
    }
})
task.resume()

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}

Code

require 'json'
require 'net/http'

api_url = "" # Provided by b2_authorize_account
account_id = "" # B2 Cloud Storage Account ID
account_authorization_token = "" # B2 Cloud Authorization Token
bucket_name = "" # Name of the bucket you want to create
bucket_type = "" # Either "allPublic" or "allPrivate"
uri = URI("#{api_url}/b2api/v1/b2_create_bucket")
req = Net::HTTP::Post.new(uri)
req.add_field("Authorization","#{account_authorization_token}")
req.body = "{\"accountId\":\"#{account_id}\",\"bucketName\":\"#{bucket_name}\",\"bucketType\":\"#{bucket_type}\"}"
http = Net::HTTP.new(req.uri.host, req.uri.port)
http.use_ssl = true
res = http.start {|http| http.request(req)}
case res
when Net::HTTPSuccess then
    res.body
when Net::HTTPRedirection then
    fetch(res['location'], limit - 1)
else
    res.error!
end

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}

Code

String apiUrl = "API_URL"; //Provided by b2_authorize_account
String accountAuthorizationToken = "ACCOUNT_AUTHORIZATION_TOKEN"; //Provided by b2_authorize_account
String accountId = "ACCOUNT_ID"; //B2 Cloud Storage AccountID
String bucketName = "BUCKET_NAME"; //Name for the new bucket(unique)
String bucketType = "BUCKET_TYPE"; //"allPrivate" - or - "allPublic" 
HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(apiUrl + "/b2api/v1/b2_create_bucket");
string body =
	"{\"accountId\":\"" + accountId + "\",\n" +
	"\"bucketName\":\"" + bucketName + "\",\n" +
	"\"bucketType\":\"" + bucketType + "\"}";
var data = Encoding.UTF8.GetBytes(body);
webRequest.Method = "POST";
webRequest.Headers.Add("Authorization", accountAuthorizationToken);
webRequest.ContentType = "application/json; charset=utf-8";
webRequest.ContentLength = data.Length;
using (var stream = webRequest.GetRequestStream())
{
	stream.Write(data, 0, data.Length);
	stream.Close();
}
WebResponse response = (HttpWebResponse)webRequest.GetResponse();
var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();
response.Close();
Console.WriteLine(responseString);

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}

Code

$account_id = ""; // Obtained from your B2 account page
$api_url = ""; // From b2_authorize_account call
$auth_token = ""; // From b2_authorize_account call
$bucket_name = ""; // 6 char min, 50 char max: letters, digits, - and _
$bucket_type = "allPrivate"; // Either allPublic or allPrivate

$session = curl_init($api_url .  "/b2api/v1/b2_create_bucket");

// Add post fields
$data = array("accountId" => $account_id, "bucketName" => $bucket_name, "bucketType" => $bucket_type);
$post_fields = json_encode($data);
curl_setopt($session, CURLOPT_POSTFIELDS, $post_fields); 

// Add headers
$headers = array();
$headers[] = "Authorization: " . $auth_token;
curl_setopt($session, CURLOPT_HTTPHEADER, $headers); 

curl_setopt($session, CURLOPT_POST, true); // HTTP POST
curl_setopt($session, CURLOPT_RETURNTRANSFER, true);  // Receive server response
$server_output = curl_exec($session); // Let's do this!
curl_close ($session); // Clean up
echo ($server_output); // Tell me about the rabbits, George!

Output

{
	"accountId" : "010203040506",
	"bucketId" : "4a48fe8875c6214145260818",
	"bucketInfo" : {},
	"bucketName" : "any-name-you-pick",
	"bucketType" : "allPrivate",
	"lifecycleRules" : []
}