Azure Data Tables Py

by microsoft354361d83247MITListed Oct 8, 2026Updated Oct 8, 2026

Azure Tables SDK for Python (Storage and Cosmos DB). Use for NoSQL key-value storage, entity CRUD, and batch operations. Triggers: "table storage", "TableServiceClient", "TableClient", "entities", "PartitionKey", "RowKey".

FeaturedInstructions onlySoftware Development DevOps & Cloud

AI-generated overview

Guides Python developers using the Azure Tables SDK for entity CRUD, queries, and batch operations.

What it does: This skill provides reference instructions for using the Azure Tables SDK for Python with Azure Storage Tables or the Cosmos DB Table API. It covers installation, authentication with DefaultAzureCredential, client lifecycle, table and entity operations, query filters, batch transactions, async clients, and data type mappings. It produces code guidance and best practices rather than executable scripts.
When to use it: Use it when writing Python code that stores or retrieves structured NoSQL data in Azure Tables. It fits tasks involving TableServiceClient, TableClient, entities, PartitionKey and RowKey design, or batch operations.
Requirements: Requires Python with the azure-data-tables and azure-identity packages, Azure credentials or managed identity, and network access to an Azure Storage Tables or Cosmos DB Table API endpoint. It ships no scripts; it is instructions only.

Azure Tables SDK for Python

NoSQL key-value store for structured data (Azure Storage Tables or Cosmos DB Table API).

Installation

Environment Variables

bash

# Azure Storage TablesAZURE_STORAGE_ACCOUNT_URL=https://<account>.table.core.windows.net  # Required for Azure Storage Tables
# Cosmos DB Table APICOSMOS_TABLE_ENDPOINT=https://<account>.table.cosmos.azure.com  # Required for Cosmos DB Table APIAZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

# Azure Storage TablesAZURE_STORAGE_ACCOUNT_URL=https://<account>.table.core.windows.net  # Required for Azure Storage Tables
# Cosmos DB Table APICOSMOS_TABLE_ENDPOINT=https://<account>.table.cosmos.azure.com  # Required for Cosmos DB Table APIAZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production

Authentication & Lifecycle

🔑 Two rules apply to every code sample below:

Prefer DefaultAzureCredential. It works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change. Avoid connection strings, account/API keys — they bypass Entra audit and rotation.

Local dev: DefaultAzureCredential works as-is.

Production: set AZURE_TOKEN_CREDENTIALS=prod (or AZURE_TOKEN_CREDENTIALS=<specific_credential>) to constrain the credential chain to production-safe credentials.

Wrap every client in a context manager so HTTP transports, sockets, and token caches are released deterministically:

Sync: with <Client>(...) as client:

Async: async with <Client>(...) as client: and async with DefaultAzureCredential() as credential: (from azure.identity.aio)

Snippets may abbreviate this setup, but production code should always follow both rules.

python

import osfrom azure.identity import DefaultAzureCredential, ManagedIdentityCredentialfrom azure.data.tables import TableServiceClient, TableClient
# Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>credential = DefaultAzureCredential(require_envvar=True)# Or use a specific credential directly in production:# See https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes# credential = ManagedIdentityCredential()
endpoint = "https://<account>.table.core.windows.net"
# Service client (manage tables)with TableServiceClient(endpoint=endpoint, credential=credential) as service_client:    # Use service_client here (see following sections for operations)    ...
# Table client (work with entities)with TableClient(endpoint=endpoint, table_name="mytable", credential=credential) as table_client:    # Use table_client here (see following sections for operations)    ...

import osfrom azure.identity import DefaultAzureCredential, ManagedIdentityCredentialfrom azure.data.tables import TableServiceClient, TableClient
# Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>credential = DefaultAzureCredential(require_envvar=True)# Or use a specific credential directly in production:# See https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes# credential = ManagedIdentityCredential()
endpoint = "https://<account>.table.core.windows.net"
# Service client (manage tables)with TableServiceClient(endpoint=endpoint, credential=credential) as service_client:    # Use service_client here (see following sections for operations)    ...
# Table client (work with entities)with TableClient(endpoint=endpoint, table_name="mytable", credential=credential) as table_client:    # Use table_client here (see following sections for operations)    ...

Client Types

Table Operations

python

# Create tableservice_client.create_table("mytable")
# Create if not existsservice_client.create_table_if_not_exists("mytable")
# Delete tableservice_client.delete_table("mytable")
# List tablesfor table in service_client.list_tables():    print(table.name)
# Get table clienttable_client = service_client.get_table_client("mytable")

# Create tableservice_client.create_table("mytable")
# Create if not existsservice_client.create_table_if_not_exists("mytable")
# Delete tableservice_client.delete_table("mytable")
# List tablesfor table in service_client.list_tables():    print(table.name)
# Get table clienttable_client = service_client.get_table_client("mytable")

Entity Operations

Important: Every entity requires PartitionKey and RowKey (together form unique ID).

Create Entity

python

entity = {    "PartitionKey": "sales",    "RowKey": "order-001",    "product": "Widget",    "quantity": 5,    "price": 9.99,    "shipped": False}
# Create (fails if exists)table_client.create_entity(entity=entity)
# Upsert (create or replace)table_client.upsert_entity(entity=entity)

entity = {    "PartitionKey": "sales",    "RowKey": "order-001",    "product": "Widget",    "quantity": 5,    "price": 9.99,    "shipped": False}
# Create (fails if exists)table_client.create_entity(entity=entity)
# Upsert (create or replace)table_client.upsert_entity(entity=entity)

Get Entity

python

# Get by key (fastest)entity = table_client.get_entity(    partition_key="sales",    row_key="order-001")print(f"Product: {entity['product']}")

# Get by key (fastest)entity = table_client.get_entity(    partition_key="sales",    row_key="order-001")print(f"Product: {entity['product']}")

Update Entity

python

# Replace entire entityentity["quantity"] = 10table_client.update_entity(entity=entity, mode="replace")
# Merge (update specific fields only)update = {    "PartitionKey": "sales",    "RowKey": "order-001",    "shipped": True}table_client.update_entity(entity=update, mode="merge")

# Replace entire entityentity["quantity"] = 10table_client.update_entity(entity=entity, mode="replace")
# Merge (update specific fields only)update = {    "PartitionKey": "sales",    "RowKey": "order-001",    "shipped": True}table_client.update_entity(entity=update, mode="merge")

Delete Entity

Query Entities

Query Within Partition

python

# Query by partition (efficient)entities = table_client.query_entities(    query_filter="PartitionKey eq 'sales'")for entity in entities:    print(entity)

# Query by partition (efficient)entities = table_client.query_entities(    query_filter="PartitionKey eq 'sales'")for entity in entities:    print(entity)

Query with Filters

python

# Filter by propertiesentities = table_client.query_entities(    query_filter="PartitionKey eq 'sales' and quantity gt 3")
# With parameters (safer)entities = table_client.query_entities(    query_filter="PartitionKey eq @pk and price lt @max_price",    parameters={"pk": "sales", "max_price": 50.0})

# Filter by propertiesentities = table_client.query_entities(    query_filter="PartitionKey eq 'sales' and quantity gt 3")
# With parameters (safer)entities = table_client.query_entities(    query_filter="PartitionKey eq @pk and price lt @max_price",    parameters={"pk": "sales", "max_price": 50.0})

Select Specific Properties

python

entities = table_client.query_entities(    query_filter="PartitionKey eq 'sales'",    select=["RowKey", "product", "price"])

entities = table_client.query_entities(    query_filter="PartitionKey eq 'sales'",    select=["RowKey", "product", "price"])

List All Entities

python

# List all (cross-partition - use sparingly)for entity in table_client.list_entities():    print(entity)

# List all (cross-partition - use sparingly)for entity in table_client.list_entities():    print(entity)

Batch Operations

python

from azure.data.tables import TableTransactionError
# Batch operations (same partition only!)operations = [    ("create", {"PartitionKey": "batch", "RowKey": "1", "data": "first"}),    ("create", {"PartitionKey": "batch", "RowKey": "2", "data": "second"}),    ("upsert", {"PartitionKey": "batch", "RowKey": "3", "data": "third"}),]
try:    table_client.submit_transaction(operations)except TableTransactionError as e:    print(f"Transaction failed: {e}")

from azure.data.tables import TableTransactionError
# Batch operations (same partition only!)operations = [    ("create", {"PartitionKey": "batch", "RowKey": "1", "data": "first"}),    ("create", {"PartitionKey": "batch", "RowKey": "2", "data": "second"}),    ("upsert", {"PartitionKey": "batch", "RowKey": "3", "data": "third"}),]
try:    table_client.submit_transaction(operations)except TableTransactionError as e:    print(f"Transaction failed: {e}")

Async Client

python

from azure.data.tables.aio import TableServiceClient, TableClientfrom azure.identity.aio import DefaultAzureCredential
async def table_operations():    async with DefaultAzureCredential() as credential:        async with TableClient(            endpoint="https://<account>.table.core.windows.net",            table_name="mytable",            credential=credential        ) as client:            # Create            await client.create_entity(entity={                "PartitionKey": "async",                "RowKey": "1",                "data": "test"            })                        # Query            async for entity in client.query_entities("PartitionKey eq 'async'"):                print(entity)
import asyncioasyncio.run(table_operations())

from azure.data.tables.aio import TableServiceClient, TableClientfrom azure.identity.aio import DefaultAzureCredential
async def table_operations():    async with DefaultAzureCredential() as credential:        async with TableClient(            endpoint="https://<account>.table.core.windows.net",            table_name="mytable",            credential=credential        ) as client:            # Create            await client.create_entity(entity={                "PartitionKey": "async",                "RowKey": "1",                "data": "test"            })                        # Query            async for entity in client.query_entities("PartitionKey eq 'async'"):                print(entity)
import asyncioasyncio.run(table_operations())

Data Types

Best Practices

Pick sync OR async and stay consistent. Do not mix azure.data.tables sync clients with azure.data.tables.aio async clients in the same call path. Choose one mode per module.
Always use context managers for clients and async credentials. Wrap every client in with TableClient(...) as client: (sync) or async with TableClient(...) as client: (async). For async DefaultAzureCredential from azure.identity.aio, also use async with credential: so tokens and transports are cleaned up.
Use DefaultAzureCredential for portable auth across local dev and Azure (avoid connection strings / API keys when possible).
Design partition keys for query patterns and even distribution
Query within partitions whenever possible (cross-partition is expensive)
Use batch operations for multiple entities in same partition
Use upsert_entity for idempotent writes
Use parameterized queries to prevent injection
Keep entities small — max 1MB per entity
Use async client for high-throughput scenarios

Reference Files

File	Contents
references/capabilities.md [blocked]	Additional non-hero capabilities, operation-group coverage, and production checklists.
references/non-hero-scenarios.md [blocked]	Dedicated non-hero examples for secondary/advanced scenarios.

Source and attribution

Source:microsoft/skillsin.github/plugins/azure-sdk-python/skills/azure-data-tables-pyat commit354361d

License: MIT

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Client	Purpose
`TableServiceClient`	Create/delete tables, list tables
`TableClient`	Entity CRUD, queries

Python Type	Table Storage Type
`str`	String
`int`	Int64
`float`	Double
`bool`	Boolean
`datetime`	DateTime
`bytes`	Binary
`UUID`	Guid

Azure Data Tables Py

Azure Tables SDK for Python

Installation

Environment Variables

Authentication & Lifecycle

Client Types

Table Operations

Entity Operations

Create Entity

Get Entity

Update Entity

Delete Entity

Query Entities

Query Within Partition

Query with Filters

Select Specific Properties

List All Entities

Batch Operations

Async Client

Data Types

Best Practices

Reference Files

Source and attribution

More from microsoft/skills

Customize

Discover Azure Skills

Azure Resource Visualizer

Azure Resource Lookup

Azure Messaging

Azure Kusto

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Gemini Live Api

Gemini Api