Getting started with the Amazon QuickSight API

Install AWS SDK in your environment. For instructions, see AWS Command line Interface.

Set up your AWS CLI identity and AWS Region using the following command and follow-up instructions. Use the credentials for an IAM identity or role that has the proper permissions.

aws configure

Look at Amazon QuickSight SDK help by running the following command.

aws quicksight help

To get detailed instructions on how to use an API, enter its name followed by help, as follows.

aws quicksight list-users help

Call an Amazon QuickSight API operation. The following example returns a list of Amazon QuickSight users in your account.

aws quicksight list-users --aws-account-id aws-account-id --namespace default --region us-east-1

Create a Java project in your IDE.

Import the Amazon QuickSight SDK into your new project, for example: AWSQuickSightJavaClient-1.11.x.jar

After your IDE indexes the Amazon QuickSight SDK, add an import line as follows.

import com.amazonaws.services.quicksight.AmazonQuickSight;

If your IDE doesn't recognize line this as valid, verify that you imported the SDK.

Download and import external dependencies for the Amazon QuickSight SDK.

Like other AWS SDKs, Amazon QuickSight SDK requires external dependencies to perform many of its functions. Make sure to download and import those into the same project. The following dependencies are required:

Create an Amazon QuickSight client.

You can use a default public endpoint that the client can communicate with, or you can reference the endpoint explicitly. There are multiple ways to provide your AWS credentials. In the following example, we provide a direct, simple approach.

The following client method is used to make all the API calls that follow.

private static AmazonQuickSight getClient() {
	final AWSCredentialsProvider credsProvider = new AWSCredentialsProvider() {
	@Override
	public AWSCredentials getCredentials() {
	// provide actual IAM access key and secret key here
	return new BasicAWSCredentials("access-key", "secret-key");
	}
	
	@Override
	public void refresh() {}
	};
	
	return AmazonQuickSightClientBuilder
	.standard()
	.withRegion(Regions.US_EAST_1.getName())
	.withCredentials(credsProvider)
	.build();
	}

Use the client that you just created to list all the users in our Amazon QuickSight account.

Provide the AWS account ID that you used to subscribe to Amazon QuickSight. This ID must match the AWS account ID of the caller's identity. Cross-account calls aren't supported at this time. Also, make sure that the required parameter namespace is set to default.

getClient().listUsers(new ListUsersRequest()
        .withAwsAccountId("relevant_AWS_account_ID")
        .withNamespace("default"))
        .getUserList().forEach(user -> {
            System.out.println(user.getArn());
        });

See a list of all possible API operations and the request objects they use by choosing the CTRL key and clicking the client object in your IDE view of the Amazon QuickSight interface. Or find this list in the com.amazonaws.services.quicksight package in the Amazon QuickSight JavaClient .jar file.

Set up your node environment using the following commands:

For information on configuring the Node.js with AWS SDK and setting your credentials, see the AWS SDK for JavaScript Developer Guide for SDK v2.

Use the following code example to test your setup. HTTPS is required. The example displays a full listing of Amazon QuickSight operations along with their URL request parameters, followed by a list of Amazon QuickSight users in your account.

const AWS = require('aws-sdk');
const https = require('https');

var quicksight = new AWS.Service({
    apiConfig: require('./quicksight-2018-04-01.min.json'),
    region: 'us-east-1',
});

console.log(quicksight.config.apiConfig.operations);

quicksight.listUsers({
    // Enter your actual AWS account ID
    'AwsAccountId': 'relevant_AWS_account_ID', 
    'Namespace': 'default',
}, function(err, data) {
    console.log('---');
    console.log('Errors: ');
    console.log(err);
    console.log('---');
    console.log('Response: ');
    console.log(data);
});

Create a credentials file in the AWS directory for your environment. In a Linux- or macOS-based environment, that file is called ~/.aws/credentials and looks like the following.

[default]
aws_access_key_id = Your_IAM_access_key
aws_secret_access_key = Your_IAM_secret_key

Unzip the folder botocore-1.12.10. Change directory into botocore-1.12.10 and enter the Python3 interpreter environment.

Each response comes back as a dictionary object. They each have a ResponseMetadata entry that contains request IDs and response status. Other entries are based on what type of operation you run.

As a test, use the following example code, a sample app that first creates, deletes, and lists groups. Then it lists users in a QuickSight account.

import botocore.session
default_namespace = 'default'
account_id = 'relevant_AWS_Account'

session = botocore.session.get_session()
client = session.create_client("quicksight", region_name='us-east-1')

print('Creating three groups: ')
client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup1')
client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup2')
client.create_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup3')

print('Retrieving the groups and listing them: ')
response = client.list_groups(AwsAccountId = account_id, Namespace=default_namespace)
for group in response['GroupList']:
    print(group)

print('Deleting our groups: ')
client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup1')
client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup2')
client.delete_group(AwsAccountId = account_id, Namespace=default_namespace, GroupName='MyGroup3')

response = client.list_users(AwsAccountId = account_id, Namespace=default_namespace)
for user in response['UserList']:
    print(user)

Unzip the nuget.zip file into a folder called nuget.

Create a new Console app project in Visual Studio.

Under your solution, locate app Dependencies, then open the context (right-click) menu and choose Add Packages.

In the sources list, choose Configure Sources.

Choose Add, and name the source QuickSightSDK. Browse to the nuget folder and choose Add Source.

Choose OK. Then, with QuickSightSDK selected, select all three Amazon QuickSight packages:

Choose Add Package.

Copy and paste the following sample app into your console app editor.

using System;
using Amazon.QuickSight.Model;
using Amazon.QuickSight;

namespace DotNetQuickSightSDKTest
{
    class Program
    {
        private static readonly string AccessKey = "insert_your_access_key";
        private static readonly string SecretAccessKey = "insert_your_secret_key";
        private static readonly string AccountID = "AWS_account_ID";
        private static readonly string Namespace = "default";  // leave this as default

        static void Main(string[] args)
        {
            var client = new AmazonQuickSightClient(
                AccessKey,
                SecretAccessKey, 
                Amazon.RegionEndpoint.USEast1);

            var listUsersRequest = new ListUsersRequest
            {
                AwsAccountId = AccountID,
                Namespace = Namespace
            };

            client.ListUsersAsync(listUsersRequest).Result.UserList.ForEach(
                user => Console.WriteLine(user.Arn)
            );

            var listGroupsRequest = new ListGroupsRequest
            {
                AwsAccountId = AccountID,
                Namespace = Namespace
            };

            client.ListGroupsAsync(listGroupsRequest).Result.GroupList.ForEach(
                group => Console.WriteLine(group.Arn)
            );
        }
    }
}