How to check if DynamoDB table exists?

You can use describe table API to determine whether the table exists.

Sample code:

from __future__ import print_function # Python 2/3 compatibility
import os
os.environ["TZ"] = "UTC"
import boto3

client = boto3.client('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")



response = client.describe_table(
    TableName='Movies'
)    

print(response)

If table exists:-

• You will get the response

If table doesn’t exists:-

• You will get ResourceNotFoundException

  botocore.errorfactory.ResourceNotFoundException: An error occurred (ResourceNotF
  oundException) when calling the DescribeTable operation: Cannot do operations on
  a non-existent table

Another way:-

Alternatively, you could use table.wait_until_exists(). from the docs:

Waits until this Table is exists. This method calls
DynamoDB.Waiter.table_exists.wait() which polls.
DynamoDB.Client.describe_table() every 20 seconds until a successful
state is reached. An error is returned after 25 failed checks.

See also: AWS API Documentation

Request Syntax

table.wait_until_exists()

Returns

None

import boto3

from botocore.exceptions import ClientError

TABLE_NAME = "myTableName"
dynamodb = boto3.resource('dynamodb', endpoint_url="https://dynamodb.us-east-1.amazonaws.com")

table = dynamodb.Table(TABLE_NAME)

try:
    response = client.describe_table(TableName=TABLE_NAME)

except ClientError as ce:
if ce.response['Error']['Code'] == 'ResourceNotFoundException':
    print "Table " + TABLE_NAME + " does not exist. Create the table first and try again."
else:
    print "Unknown exception occurred while querying for the " + TABLE_NAME + " table. Printing full error:"
    pprint.pprint(ce.response)

You can use .table_status attr of any boto3 Table instance object. It returns it’s status if exists (CREATING, UPDATING, DELETING, ACTIVE) or throws exception botocore.exceptions.ClientError: Requested resource not found: Table: <YOUR_TABLE_NAME> not found. You can wrap those conditions into try / except to have full info on the current table state.

import boto3
from botocore.exceptions import ClientError

dynamodb = boto3.resource('dynamodb', region_name='us-west-2')
table = dynamodb.Table('your_table_name_str')

try:
  is_table_existing = table.table_status in ("CREATING", "UPDATING",
                                             "DELETING", "ACTIVE")
except ClientError:
  is_table_existing = False
  print "Table %s doesn't exist." % table.name

Alternate approach if you do not want to use boto3.client but only boto3.resource:

import boto3

database = boto3.resource('dynamodb', endpoint_url="http://localhost:8000")    

table_name  = 'MyTable'
table_names = [table.name for table in database.tables.all()]

if table_name in table_names:
    print('table', table_name, 'exists')

Note that it kind of depends on if you are using client or resource. If you use boto3.client(), you can use the 3 methods the accepted answer suggested. If you are using boto3.resource(), you can only use dynamodb_resource.create_table() and check exceptions.

try:
    table = dynamodb_resource.create_table(
        ...
    )
    table.meta.client.get_waiter('table_exists').wait(TableName=your_table_name)
except ResourceInUseException:
    # do sth here

I know this will have a slight risk if there are more than 10 tables between table.split(0, -1) and table. However, it does save throwing exceptions and the like.
Alas the documentation https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ListTables.html (examples) imply the the first table in the returned list will be the search item, it is not the case..

class Dynamo {

private m_db!: DynamoDB;

private async ensure_table(name: string) {
    const search = await this.db().listTables({
        ExclusiveStartTableName: name.slice(0, -1),
        Limit: 10 });
    const exists = search.TableNames?.includes(name);
    exists || await this.create_table(name);
}

private async create_table(name: string) {
   // create the table here 
}

 
private db(): DynamoDB { 
    return this.m_db || (this.m_db = this.create_db()); 
}


private create_db = (): DynamoDB => { 
    return new DynamoDB({apiVersion: "2012-08-10"}); }
}

}

You can use the convenient resource API while still handling and catching the exceptions from the client API level, because you can access the client from the resource! This makes the method of checking if table exists the most elegant I have found:

resource = boto3.resource('dynamodb', region_name='eu-north-1')

def table_exists(table_name: str) -> bool:
    try:
        resource.Table(table_name).table_status
    except resource.meta.client.exceptions.ResourceNotFoundException:
        return False
    return True

print(table_exists('dummy_table'))