---
title: "AWS SDK for C++ With Wasabi"
slug: "how-do-i-use-aws-sdk-for-cpp-with-wasabi"
updated: 2026-07-29T20:14:38Z
published: 2026-07-29T20:14:38Z
canonical: "docs.wasabi.com/how-do-i-use-aws-sdk-for-cpp-with-wasabi"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wasabi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# AWS SDK for C++ (v1) With Wasabi

[AWS SDK for C++](https://aws.amazon.com/sdk-for-cpp/) v1 is validated for use with Wasabi.

## Using the C++ SDK

Execute the following steps.

1. Install the [AWS SDK for C++ using CMAKE](https://github.com/aws/aws-sdk-cpp).
2. (Optional) Configure an additional [AWS CLI profile for Wasabi](https://docs.wasabi.com/docs/how-do-i-use-aws-cli-with-wasabi) account using the Wasabi keys.

In this example, we set the profile name as "wasabi" in the "~/.aws/credentials" file. To help you use this SDK with Wasabi, we provided examples for both IAM and S3.

- Setting the Credentials
- Connecting to IAM and S3 Endpoints
- Creating a User Using IAM
- Creating a Bucket
- Uploading an Object to the Bucket
- Reading an Object From the Bucket
- Deleting an Object From the Bucket

Additional examples are available from the [AWS documentation](https://docs.aws.amazon.com/aws-sdk-php/v2/guide/).

> [!NOTE]
> The examples use Wasabi's us-east-1 storage region. For other Wasabi storage regions, use the appropriate [Wasabi service URL](https://docs.wasabi.com/docs/what-are-the-service-urls-for-wasabis-different-storage-regions).

> [!NOTE]
> Send all IAM requests to [iam.wasabisys.com](http://sts.wasabisys.com/)

The following is an example CMakeLists.txt file.

```plaintext
cmake_minimum_required(VERSION 3.5)
project(aws-sdk-cpp-sample)//This is an example name

# Set the C++ standard
set(CMAKE_CXX_STANDARD 11)

# Find the AWS SDK for C++
find_package(AWSSDK REQUIRED COMPONENTS s3 iam)

# Add the executable
add_executable(${PROJECT_NAME} main.cpp) //change according to the function file name

# Link the AWS SDK for C++ libraries
target_link_libraries(${PROJECT_NAME} ${AWSSDK_LINK_LIBRARIES})
```

## Setting the Credentials

```plaintext
#include <aws/core/Aws.h> 
#include <aws/core/auth/AWSCredentialsProvider.h> 
#include <aws/core/client/ClientConfiguration.h> 
#include <aws/iam/IAMClient.h> 
#include <aws/s3/S3Client.h> 
#include <memory> 

int main() { 
Aws::SDKOptions options; 
Aws::InitAPI(options); 

// Specify the profile name from which credentials will be loaded 
const Aws::String profileName = "wasabi"; 

// Create a client configuration 
Aws::Client::ClientConfiguration clientConfig; 

// Create a credentials provider using the specified profile name 
auto credentialsProvider = Aws::MakeShared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str()); 

// IAM client setup 
Aws::IAM::IAMClient iamClient(credentialsProvider, clientConfig); 

// S3 client setup 
Aws::S3::S3Client s3Client(credentialsProvider, clientConfig, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never, false); 

// Continue with your code... 
Aws::ShutdownAPI(options); 
return 0; 
} 
```

## Connecting to IAM and S3 Endpoints

#### IAM

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/iam/IAMClient.h>
#include <aws/iam/model/GetUserRequest.h>
#include <aws/iam/model/GetUserResult.h>
#include <iostream>
#include <memory>

int main() {

    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {

        const Aws::String profileName = "wasabi";
        Aws::Client::ClientConfiguration clientConfig;
        clientConfig.endpointOverride = "https://iam.wasabisys.com";
        auto credentialsProvider = std::make_shared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str());
        Aws::IAM::IAMClient iamClient(credentialsProvider, clientConfig);

       // Test by using the current user, don't remember the username

        Aws::IAM::Model::GetUserRequest request;
        auto outcome = iamClient.GetUser(request);

        if (outcome.IsSuccess()) {
            std::cout << "Connection successful" << std::endl;
        } else {
            std::cerr << "Connection failed: " << outcome.GetError().GetMessage() << std::endl;
        }
    }

    Aws::ShutdownAPI(options);
    return 0;
}
```

#### S3

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/ListBucketsResult.h>
#include <iostream>
#include <memory>

int main() {
    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {
        const Aws::String profileName = "wasabi";
        Aws::Client::ClientConfiguration clientConfig;
        clientConfig.endpointOverride = "https://s3.wasabisys.com";
        auto credentialsProvider = std::make_shared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str());
        Aws::S3::S3Client s3Client(credentialsProvider, clientConfig, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never, false);

        // Testing connection using list buckets.
        auto outcome = s3Client.ListBuckets();

        if (outcome.IsSuccess()) {
            std::cout << "List of buckets:" << std::endl;
            const auto& buckets = outcome.GetResult().GetBuckets();
            for (const auto& bucket : buckets) {
                std::cout << "Bucket: " << bucket.GetName() << std::endl;
            }
        } else {
            std::cerr << "Failed to list buckets: " << outcome.GetError().GetMessage() << std::endl;
        }
    }
    Aws::ShutdownAPI(options);
    return 0;
}
```

## Creating a User Using IAM

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/iam/IAMClient.h>
#include <aws/iam/model/CreateUserRequest.h>
#include <iostream>
#include <memory>

bool createIAMUser(const Aws::String& userName, const Aws::String& profileName, const Aws::String& endpointOverride) {
    // Initialize AWS SDK
    Aws::SDKOptions options;
    Aws::InitAPI(options);

    // Set up client configuration
    Aws::Client::ClientConfiguration clientConfig;
    clientConfig.endpointOverride = endpointOverride;

    // Set up credentials provider using profile name
    auto credentialsProvider = std::make_shared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str());

    // Set up IAM client
    Aws::IAM::IAMClient iamClient(credentialsProvider, clientConfig);

    // Create IAM user request
    Aws::IAM::Model::CreateUserRequest createRequest;
    createRequest.SetUserName(userName);

    // Send the request to create the IAM user
    auto outcome = iamClient.CreateUser(createRequest);

    // Check if the operation was successful
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Failed to create IAM user " << userName << ": " << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
        Aws::ShutdownAPI(options);
        return false;
    }

    std::cout << "Successfully created IAM user " << userName << std::endl;

    // Clean up and shutdown the AWS SDK
    Aws::ShutdownAPI(options);
    return true;
}

int main() {
    const Aws::String userName = "your-iam-user-name";
    const Aws::String profileName = "wasabi";
    const Aws::String endpointOverride = "https://iam.wasabisys.com";

    if (createIAMUser(userName, profileName, endpointOverride)) {
        std::cout << "IAM user created successfully!" << std::endl;
    } else {
        std::cerr << "Failed to create IAM user." << std::endl;
    }

    return 0;
}
```

## Creating a Bucket

```plaintext
#include <iostream>
#include <aws/core/Aws.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/CreateBucketRequest.h>
#include <aws/s3/model/BucketLocationConstraint.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>

bool createBucket(const Aws::String& bucketName, const Aws::String&Region, const Aws::String& profileName, const Aws::String& endpointOverride) {

// Initialize AWS SDK
Aws::SDKOptions options;
Aws::InitAPI(options);

// Set up client configuration
Aws::Client::ClientConfiguration clientConfig;
clientConfig.region = Region;
clientConfig.endpointOverride = endpointOverride;

// Set up credentials provider using profile name
auto credentialsProvider = std::make_shared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str());

// Set up S3 client
Aws::S3::S3Client s3Client(credentialsProvider, clientConfig, Aws::Client::AWSAuthV4Signer::PayloadSigningPolicy::Never, false);

// Create bucket request
Aws::S3::Model::CreateBucketRequest request;
request.SetBucket(bucketName);

// If the region is not us-east-1, set the location constraint
if (Region != "us-east-1") {
Aws::S3::Model::CreateBucketConfiguration createBucketConfig;
createBucketConfig.SetLocationConstraint(
Aws::S3::Model::BucketLocationConstraintMapper::GetBucketLocationConstraintForName(Region));
request.SetCreateBucketConfiguration(createBucketConfig);
}

// Send the request to create the bucket
auto outcome = s3Client.CreateBucket(request);

// Check if the operation was successful
if (!outcome.IsSuccess()) {
auto err = outcome.GetError();
std::cerr << "Failed to create bucket: " << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
Aws::ShutdownAPI(options);
return false;
}
std::cout << "Bucket " << bucketName << " created successfully in region " << Region << std::endl;

// Clean up and shutdown the AWS SDK
Aws::ShutdownAPI(options);
return true;
}

int main() {

const Aws::String bucketName = "<bucket-name>";
const Aws::String Region = "us-east-1"; // Change this to your desired AWS region
const Aws::String profileName = "wasabi";
const Aws::String endpointOverride = "https://s3.wasabisys.com"; //change the Endpoint according to the region

if (createBucket(bucketName, Region, profileName, endpointOverride)) {
std::cout << "Bucket created successfully!" << std::endl;
} else {
std::cerr << "Failed to create bucket." << std::endl;
}
return 0;
}
```

## Upload an Object to the Bucket

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/PutObjectRequest.h>
#include <iostream>
#include <fstream>

bool uploadFileToS3WithWasabiProfile(const Aws::String& bucketName,
const Aws::String& filePath,
const Aws::String& awsRegion) {
// Initialize AWS SDK
Aws::SDKOptions options;
Aws::InitAPI(options);

// Set the AWS profile name
const Aws::String profileName = "wasabi";

// Set up client configuration
Aws::Client::ClientConfiguration clientConfig;
clientConfig.endpointOverride = "https://s3.wasabisys.com";

// Set up credentials provider using profile name
auto credentialsProvider = Aws::MakeShared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>("profile_provider");

// Set up S3 client
Aws::S3::S3Client s3Client(clientConfig); // Only pass client configuration

// Open the file for upload
std::ifstream fileStream(filePath.c_str(), std::ios::binary); // Open the file
if (!fileStream.is_open()) {
std::cerr << "Failed to open file: " << filePath << std::endl;
Aws::ShutdownAPI(options);
return false;
}

// Upload the file
Aws::S3::Model::PutObjectRequest request;
request.SetBucket(bucketName);
request.SetKey("<key-name>"); // Set the key name

// Set the body of the request using the file stream
auto bodyStream = Aws::MakeShared<Aws::FStream>("UploadFile", filePath.c_str(), std::ios_base::in);
request.SetBody(bodyStream);

auto outcome = s3Client.PutObject(request);
fileStream.close();

if (!outcome.IsSuccess()) {
std::cerr << "Failed to upload file: " << outcome.GetError().GetMessage() << std::endl;
Aws::ShutdownAPI(options);
return false;
}

Aws::ShutdownAPI(options);
return true;
}

int main() {
Aws::SDKOptions options;
Aws::InitAPI(options);
{
const Aws::String bucketName = "<bucket-name>";
const Aws::String filePath = "/path/to/your/file"; // Provide the full file path here including the file name/Key name

if (uploadFileToS3WithWasabiProfile(bucketName, filePath, "us-east-1")) {
std::cout << "File uploaded successfully to S3!" << std::endl;
} else {
std::cerr << "Failed to upload file to S3." << std::endl;
}
}
Aws::ShutdownAPI(options);

return 0;
}
```

## Reading an Object From the Bucket

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/GetObjectRequest.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <aws/core/utils/logging/LogLevel.h>

bool getObjectFromS3(const Aws::String& objectKey, const Aws::String& fromBucket, Aws::S3::S3Client& s3Client) {
    // Create GetObjectRequest
    Aws::S3::Model::GetObjectRequest request;
    request.SetBucket(fromBucket);
    request.SetKey(objectKey);

    // Get the object
    auto outcome = s3Client.GetObject(request);

    // Check if the operation was successful
    if (!outcome.IsSuccess()) {
        auto err = outcome.GetError();
        std::cerr << "Failed to get object '" << objectKey << "' from bucket '" << fromBucket << "': " << err.GetExceptionName() << ": " << err.GetMessage() << std::endl;
        return false;
    }

    // Read the content of the object
    const Aws::IOStream& bodyStream = outcome.GetResult().GetBody();
    std::stringstream ss;
    ss << bodyStream.rdbuf();
    std::string content = ss.str();

    // Print the content of the object
    std::cout << "Content of object '" << objectKey << "':" << std::endl;
    std::cout << content << std::endl;

    return true;
}
int main() {

    std::string profileName = "wasabi";
    setenv("AWS_PROFILE", profileName.c_str(), 1);

    // Initialize AWS SDK
    Aws::SDKOptions options;
    Aws::InitAPI(options);

    // Specify the object key and bucket name
    const Aws::String objectKey = "<key-name>";
    const Aws::String bucketName = "<bucket-name>";

    // Set up client configuration
    Aws::Client::ClientConfiguration clientConfig;
    clientConfig.endpointOverride = "s3.wasabisys.com";
    clientConfig.scheme = Aws::Http::Scheme::HTTPS;
    clientConfig.region = "us-east-1";

    // Create S3 client with client configuration
    Aws::S3::S3Client s3Client(clientConfig);

    // Read the object from S3
    if (getObjectFromS3(objectKey, bucketName, s3Client)) {
        std::cout << "Object downloaded successfully!" << std::endl;
    } else {
        std::cerr << "Failed to download object." << std::endl;
    }

    // Shutdown AWS SDK
    Aws::ShutdownAPI(options);

    return 0;
}
```

## Deleting an Object From the Bucket

```plaintext
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/s3/S3Client.h>
#include <aws/s3/model/DeleteObjectRequest.h>
#include <iostream>

bool deleteObjectFromS3WithWasabiProfile(const Aws::String& objectKey,
const Aws::String&fromBucket,const Aws::String& Region) {
    // Initialize AWS SDK
    Aws::SDKOptions options;
    Aws::InitAPI(options);

    // Set up client configuration
    Aws::Client::ClientConfiguration clientConfig;
    clientConfig.endpointOverride = "https://s3.wasabisys.com";

    // Set up credentials provider using profile name
    auto credentialsProvider = Aws::MakeShared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>("wasabi");
 
    // Set up S3 client
    Aws::S3::S3Client s3Client(clientConfig);

    // Delete the object
    Aws::S3::Model::DeleteObjectRequest request;
    request.SetKey(objectKey);
    request.SetBucket(fromBucket);

    auto outcome = s3Client.DeleteObject(request);

    if (!outcome.IsSuccess()) {
        std::cerr << "Failed to delete object: " << outcome.GetError().GetMessage() << std::endl;
        Aws::ShutdownAPI(options);
        return false;
    }

    std::cout << "Object deleted successfully from S3!" << std::endl;

    // Clean up and shutdown the AWS SDK
    Aws::ShutdownAPI(options);
    return true;
}

int main() {
    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {
        const Aws::String objectKey = "<key-name>"; // Provide the object key here
        const Aws::String fromBucket = "<bucket-name>"; // Provide the bucket name here
        const Aws::String Region = "us-east-1"; // Provide the AWS region here

        if (deleteObjectFromS3WithWasabiProfile(objectKey, fromBucket, Region)) {
            std::cout << "Object deleted successfully from S3!" << std::endl;
        } else {
            std::cerr << "Failed to delete object from S3." << std::endl;
        }
    }
    Aws::ShutdownAPI(options);

    return 0;
}
```