How to copy a DynamoDB table to another account or Region

To copy a DynamoDB table into a new table, use a backup restore, PITR restore, or export to S3 followed by import from S3. For an existing destination table, use application writes, a paginated scan-and-batch-write script, or an ETL job. Choose the method based on whether you need a consistent recovery point, another account or Region, a different schema, or ongoing synchronization.

Choose the copy method

A copy is not automatically a migration. If the source remains writable, you need a write freeze or a change-capture and reconciliation phase before moving traffic. Global tables are an option for ongoing replication, not a retained point-in-time copy.

Preparation

Record source and destination account IDs, Regions, table names and key schemas. Confirm whether overwriting destination items is permitted. Take a recoverable backup before changing an existing target, and identify the roles used for reading, writing, exporting, importing or restoring.

Preserve the destination access patterns, not just the items. Check primary keys, GSIs, LSIs, encryption, TTL, streams, capacity, tags, resource policies, backup settings and alarms. An item copy does not create those settings. If an import needs a different primary key, every source record must contain valid values for the new schema.

Set up AWS CLI profiles

Use temporary credentials through IAM Identity Center or an approved assumed-role profile. You do not need to create a new IAM user with unrestricted DynamoDB access just to copy data. For an organization using Identity Center, configure and authenticate profiles for the source and destination:

aws configure sso --profile source
aws configure sso --profile destination
aws sso login --profile source
aws sso login --profile destination
aws sts get-caller-identity --profile source
aws sts get-caller-identity --profile destination
aws configure sso --profile source
aws configure sso --profile destination
aws sso login --profile source
aws sso login --profile destination
aws sts get-caller-identity --profile source
aws sts get-caller-identity --profile destination

Verify the returned account IDs before writing. Follow the CLI Identity Center setup for your organization's sign-in configuration. The required permissions depend on the method: a scan copier needs source reads and destination writes; a managed export/import also needs S3 and potentially KMS access. See DynamoDB access control for scoped roles and cross-account policies.

Copy a table to another account with S3 export and import

A full native export reads a snapshot from the source table's PITR history without consuming table read capacity. The destination account can import the exported files into a new table when its role has the necessary bucket and key access. This avoids transporting the whole dataset through a laptop.

1. Export a full snapshot

Enable PITR first and confirm a restorable point is available. Request the export using credentials from the source table's account:

EXPORT_ARN=$(aws dynamodb export-table-to-point-in-time \
  --profile source \
  --region us-east-1 \
  --table-arn arn:aws:dynamodb:us-east-1:123456789012:table/Orders \
  --s3-bucket example-orders-transfer \
  --s3-prefix orders-copy \
  --export-format DYNAMODB_JSON \
  --export-type FULL_EXPORT \
  --query 'ExportDescription.ExportArn' \
  --output text)

aws dynamodb describe-export \
  --profile source \
  --region us-east-1 \
  --export-arn "$EXPORT_ARN"
EXPORT_ARN=$(aws dynamodb export-table-to-point-in-time \
  --profile source \
  --region us-east-1 \
  --table-arn arn:aws:dynamodb:us-east-1:123456789012:table/Orders \
  --s3-bucket example-orders-transfer \
  --s3-prefix orders-copy \
  --export-format DYNAMODB_JSON \
  --export-type FULL_EXPORT \
  --query 'ExportDescription.ExportArn' \
  --output text)

aws dynamodb describe-export \
  --profile source \
  --region us-east-1 \
  --export-arn "$EXPORT_ARN"

Replace the account and bucket values. Omitting the export time uses the latest available point; provide a verified historical time if the copy must precede a change. Wait for export status COMPLETED, and inspect failures instead of treating the returned ARN as completion. For a bucket owned by another account, include its owner and configure its permissions as described in requesting an export.

2. Select the data prefix, not the export root

A full export writes manifests and compressed data files. The data objects are under a prefix shaped like:

orders-copy/AWSDynamoDB/EXPORT-ID/data/
orders-copy/AWSDynamoDB/EXPORT-ID/data/

Find the actual export ID and data location in the completed export's manifest. Do not point import at the root containing manifest and checksum files. The export output specification describes the layout.

A filtered export copies a subset, and an incremental export represents changes over an interval. Neither should be mistaken for the full dataset required for a straightforward clone. Applying incremental changes, including deletes, requires a separate designed process.

3. Import into a new destination table

Save this as orders-import.json. It assumes the source has string keys pk and sk; change the schema to match your data, and replace the bucket owner and actual data prefix:

{
  "S3BucketSource": {
    "S3Bucket": "example-orders-transfer",
    "S3BucketOwner": "123456789012",
    "S3KeyPrefix": "orders-copy/AWSDynamoDB/REPLACE-WITH-EXPORT-ID/data/"
  },
  "InputFormat": "DYNAMODB_JSON",
  "InputCompressionType": "GZIP",
  "TableCreationParameters": {
    "TableName": "OrdersCopy",
    "BillingMode": "PAY_PER_REQUEST",
    "AttributeDefinitions": [
      { "AttributeName": "pk", "AttributeType": "S" },
      { "AttributeName": "sk", "AttributeType": "S" }
    ],
    "KeySchema": [
      { "AttributeName": "pk", "KeyType": "HASH" },
      { "AttributeName": "sk", "KeyType": "RANGE" }
    ]
  }
}
{
  "S3BucketSource": {
    "S3Bucket": "example-orders-transfer",
    "S3BucketOwner": "123456789012",
    "S3KeyPrefix": "orders-copy/AWSDynamoDB/REPLACE-WITH-EXPORT-ID/data/"
  },
  "InputFormat": "DYNAMODB_JSON",
  "InputCompressionType": "GZIP",
  "TableCreationParameters": {
    "TableName": "OrdersCopy",
    "BillingMode": "PAY_PER_REQUEST",
    "AttributeDefinitions": [
      { "AttributeName": "pk", "AttributeType": "S" },
      { "AttributeName": "sk", "AttributeType": "S" }
    ],
    "KeySchema": [
      { "AttributeName": "pk", "KeyType": "HASH" },
      { "AttributeName": "sk", "KeyType": "RANGE" }
    ]
  }
}

IMPORT_ARN=$(aws dynamodb import-table \
  --profile destination \
  --region us-west-2 \
  --cli-input-json file://orders-import.json \
  --query 'ImportTableDescription.ImportArn' \
  --output text)

aws dynamodb describe-import \
  --profile destination \
  --region us-west-2 \
  --import-arn "$IMPORT_ARN"
IMPORT_ARN=$(aws dynamodb import-table \
  --profile destination \
  --region us-west-2 \
  --cli-input-json file://orders-import.json \
  --query 'ImportTableDescription.ImportArn' \
  --output text)

aws dynamodb describe-import \
  --profile destination \
  --region us-west-2 \
  --import-arn "$IMPORT_ARN"

Wait for COMPLETED and inspect error counts and logs. Native import accepts DynamoDB JSON, CSV or Amazon Ion, but ordinary JSON is not interchangeable with DynamoDB JSON. It uses no destination write capacity, can define GSIs, and does not support LSIs or importing into an existing table. The import documentation covers formats and permissions.

The basic example creates no indexes beyond the primary key and no custom operational settings. Add required indexes and encryption to the import configuration, then apply the remaining table settings before cutover.

AWS Backup copy and restore across accounts

Use AWS Backup when the copy should remain part of a managed backup and retention workflow. Enable the advanced DynamoDB backup features, create a recovery point, copy it to the destination vault, then restore it in that account or Region.

For standard cross-account copy, the accounts must belong to the same AWS Organization and meet the copy prerequisites. Configure the destination vault policy, source role and relevant encryption keys. Confirm the copy job completed before restoring. The backup and restore guide walks through this route; it creates a new table rather than appending to one.

Copy a table to another Region with PITR

If the destination is in the same account and a suitable PITR point exists, a restore avoids an intermediate S3 transfer workflow. Run the restore in the destination Region with the source table ARN:

aws dynamodb restore-table-to-point-in-time \
  --profile source \
  --region us-west-2 \
  --source-table-arn arn:aws:dynamodb:us-east-1:123456789012:table/Orders \
  --target-table-name OrdersCopy \
  --use-latest-restorable-time
aws dynamodb restore-table-to-point-in-time \
  --profile source \
  --region us-west-2 \
  --source-table-arn arn:aws:dynamodb:us-east-1:123456789012:table/Orders \
  --target-table-name OrdersCopy \
  --use-latest-restorable-time

Use the same approach within one Region with a different target name. For a specific historical copy, replace the latest-time option with a valid --restore-date-time. Validate the destination's indexes, capacity and encryption, and reapply settings that restore does not carry over. The PITR guide explains those details.

S3 export/import and AWS Backup are also suitable cross-Region options. Choose one based on whether you need a portable data artifact, a different key schema or retained recovery points. A cross-Region copy does not follow later source changes automatically.

Copy into an existing table with a script

The scripts below are for controlled copies into a pre-created destination with a compatible key schema. Stop source writes, use strongly consistent reads and keep the destination isolated during the copy. Even a strongly consistent scan is not a snapshot while writes continue, as the Scan API explains.

Both scripts overwrite items with matching primary keys. They do not remove destination-only items or preserve table configuration. For “insert only if missing,” use conditional PutItem calls instead: BatchWriteItem does not support per-item conditions.

JavaScript: AWS SDK v3 with pagination and retries

Install @aws-sdk/client-dynamodb and @aws-sdk/credential-providers in the script's project. Save as copy-table.mjs, set SOURCE_TABLE, DESTINATION_TABLE, SOURCE_REGION and DESTINATION_REGION, and use the authenticated source and destination profiles.

The low-level client preserves DynamoDB number strings and binary values without converting them to ordinary JavaScript numbers. It paginates scans, limits batches by count and a conservative byte budget, and retries unprocessed writes with backoff:

import {
  DynamoDBClient,
  DescribeTableCommand,
  ScanCommand,
  BatchWriteItemCommand,
} from "@aws-sdk/client-dynamodb"
import { fromIni } from "@aws-sdk/credential-providers"
import { setTimeout as sleep } from "node:timers/promises"

const required = (name) => {
  const value = process.env[name]
  if (!value) throw new Error(`${name} is required`)
  return value
}
const sourceName = required("SOURCE_TABLE")
const destinationName = required("DESTINATION_TABLE")
const source = new DynamoDBClient({
  region: required("SOURCE_REGION"),
  credentials: fromIni({ profile: "source" }),
})
const destination = new DynamoDBClient({
  region: required("DESTINATION_REGION"),
  credentials: fromIni({ profile: "destination" }),
})
const sourceInfo = await source.send(new DescribeTableCommand({ TableName: sourceName }))
const destinationInfo = await destination.send(new DescribeTableCommand({ TableName: destinationName }))
if (sourceInfo.Table.TableArn === destinationInfo.Table.TableArn) {
  throw new Error("Source and destination must be different tables")
}
if (destinationInfo.Table.TableStatus !== "ACTIVE") {
  throw new Error("Destination must be ACTIVE")
}

const requestBytes = (requests) => Buffer.byteLength(JSON.stringify(
  { RequestItems: { [destinationName]: requests } },
  (_key, value) => value instanceof Uint8Array
    ? Buffer.from(value).toString("base64")
    : value,
))

async function writeBatch(requests) {
  let pending = requests
  for (let attempt = 0; pending.length > 0; attempt += 1) {
    if (attempt >= 12) throw new Error("Unprocessed writes remain; copy is incomplete")
    const result = await destination.send(new BatchWriteItemCommand({
      RequestItems: { [destinationName]: pending },
    }))
    pending = result.UnprocessedItems?.[destinationName] ?? []
    if (pending.length > 0) {
      await sleep(Math.random() * Math.min(10000, 100 * 2 ** attempt))
    }
  }
}

let lastKey
let copied = 0
let batch = []
do {
  const page = await source.send(new ScanCommand({
    TableName: sourceName,
    ExclusiveStartKey: lastKey,
    ConsistentRead: true,
  }))
  for (const item of page.Items ?? []) {
    const request = { PutRequest: { Item: item } }
    const candidate = [...batch, request]
    if (batch.length === 25 || requestBytes(candidate) > 8 * 1024 * 1024) {
      await writeBatch(batch)
      copied += batch.length
      batch = []
    }
    if (requestBytes([request]) > 8 * 1024 * 1024) {
      throw new Error("Item exceeds this script's request-size budget")
    }
    batch.push(request)
  }
  lastKey = page.LastEvaluatedKey
} while (lastKey && Object.keys(lastKey).length > 0)
if (batch.length > 0) {
  await writeBatch(batch)
  copied += batch.length
}
console.log(`Completed ${copied} item writes`)
import {
  DynamoDBClient,
  DescribeTableCommand,
  ScanCommand,
  BatchWriteItemCommand,
} from "@aws-sdk/client-dynamodb"
import { fromIni } from "@aws-sdk/credential-providers"
import { setTimeout as sleep } from "node:timers/promises"

const required = (name) => {
  const value = process.env[name]
  if (!value) throw new Error(`${name} is required`)
  return value
}
const sourceName = required("SOURCE_TABLE")
const destinationName = required("DESTINATION_TABLE")
const source = new DynamoDBClient({
  region: required("SOURCE_REGION"),
  credentials: fromIni({ profile: "source" }),
})
const destination = new DynamoDBClient({
  region: required("DESTINATION_REGION"),
  credentials: fromIni({ profile: "destination" }),
})
const sourceInfo = await source.send(new DescribeTableCommand({ TableName: sourceName }))
const destinationInfo = await destination.send(new DescribeTableCommand({ TableName: destinationName }))
if (sourceInfo.Table.TableArn === destinationInfo.Table.TableArn) {
  throw new Error("Source and destination must be different tables")
}
if (destinationInfo.Table.TableStatus !== "ACTIVE") {
  throw new Error("Destination must be ACTIVE")
}

const requestBytes = (requests) => Buffer.byteLength(JSON.stringify(
  { RequestItems: { [destinationName]: requests } },
  (_key, value) => value instanceof Uint8Array
    ? Buffer.from(value).toString("base64")
    : value,
))

async function writeBatch(requests) {
  let pending = requests
  for (let attempt = 0; pending.length > 0; attempt += 1) {
    if (attempt >= 12) throw new Error("Unprocessed writes remain; copy is incomplete")
    const result = await destination.send(new BatchWriteItemCommand({
      RequestItems: { [destinationName]: pending },
    }))
    pending = result.UnprocessedItems?.[destinationName] ?? []
    if (pending.length > 0) {
      await sleep(Math.random() * Math.min(10000, 100 * 2 ** attempt))
    }
  }
}

let lastKey
let copied = 0
let batch = []
do {
  const page = await source.send(new ScanCommand({
    TableName: sourceName,
    ExclusiveStartKey: lastKey,
    ConsistentRead: true,
  }))
  for (const item of page.Items ?? []) {
    const request = { PutRequest: { Item: item } }
    const candidate = [...batch, request]
    if (batch.length === 25 || requestBytes(candidate) > 8 * 1024 * 1024) {
      await writeBatch(batch)
      copied += batch.length
      batch = []
    }
    if (requestBytes([request]) > 8 * 1024 * 1024) {
      throw new Error("Item exceeds this script's request-size budget")
    }
    batch.push(request)
  }
  lastKey = page.LastEvaluatedKey
} while (lastKey && Object.keys(lastKey).length > 0)
if (batch.length > 0) {
  await writeBatch(batch)
  copied += batch.length
}
console.log(`Completed ${copied} item writes`)

The 8 MB threshold is the script's conservative batching choice, not a DynamoDB service limit. DynamoDB permits up to 25 operations and a 16 MB request; stored-item size and JSON wire size differ. SDK retries handle retryable request failures, while the loop handles successful responses containing UnprocessedItems. See BatchWriteItem.

This script stops on an unrecovered error and has no durable checkpoint. Rerun only against a quiescent source and a destination where repeated overwrites are acceptable. For a long migration, add durable progress records, rate controls and reconciliation rather than treating this example as a migration service.

Python: boto3 scan and batch writer

Boto3's table resource preserves numbers as Decimal. Its batch writer buffers writes and retries unprocessed items. This small-table example uses the same profiles and environment variables:

import os
import boto3

source_db = boto3.Session(profile_name="source").resource(
    "dynamodb", region_name=os.environ["SOURCE_REGION"]
)
destination_db = boto3.Session(profile_name="destination").resource(
    "dynamodb", region_name=os.environ["DESTINATION_REGION"]
)
source = source_db.Table(os.environ["SOURCE_TABLE"])
destination = destination_db.Table(os.environ["DESTINATION_TABLE"])
if source.table_arn == destination.table_arn:
    raise ValueError("Source and destination must be different tables")

params = {"ConsistentRead": True}
copied = 0
with destination.batch_writer() as writer:
    while True:
        page = source.scan(**params)
        for item in page.get("Items", []):
            writer.put_item(Item=item)
            copied += 1
        last_key = page.get("LastEvaluatedKey")
        if not last_key:
            break
        params["ExclusiveStartKey"] = last_key
print(f"Completed {copied} item writes")
import os
import boto3

source_db = boto3.Session(profile_name="source").resource(
    "dynamodb", region_name=os.environ["SOURCE_REGION"]
)
destination_db = boto3.Session(profile_name="destination").resource(
    "dynamodb", region_name=os.environ["DESTINATION_REGION"]
)
source = source_db.Table(os.environ["SOURCE_TABLE"])
destination = destination_db.Table(os.environ["DESTINATION_TABLE"])
if source.table_arn == destination.table_arn:
    raise ValueError("Source and destination must be different tables")

params = {"ConsistentRead": True}
copied = 0
with destination.batch_writer() as writer:
    while True:
        page = source.scan(**params)
        for item in page.get("Items", []):
            writer.put_item(Item=item)
            copied += 1
        last_key = page.get("LastEvaluatedKey")
        if not last_key:
            break
        params["ExclusiveStartKey"] = last_key
print(f"Completed {copied} item writes")

Use the boto3 helper when your batches fit the request-size limit; it is not an application-specific byte-budget or checkpoint manager. For unusually large wire representations, use explicit size-aware batches as in the JavaScript example. Both versions consume source read capacity and destination write capacity, including relevant index writes.

Use AWS Glue when the copy needs transformation

Glue can read and write DynamoDB through an ETL connector, or read a native export through its export connector. The export path avoids scanning the live table for the initial dataset and requires PITR and S3 permissions. The write path still needs destination write capacity and appropriate permissions.

Choose Glue when you must transform attributes, change key structures, join data or run an established ETL workflow. Configure the job's source and destination accounts and Regions explicitly, then validate transformed keys and duplicate handling. The Glue DynamoDB connector documentation covers these options.

Copy selected items or use a local export

For a small selected set, Dynobase's copy-items workflow lets you select a destination, map keys and choose skip or overwrite behavior. Use that when the task is moving a few records rather than cloning the entire table.

A local export/import workflow is also useful when you need a file to inspect or transform. Export the intended dataset, switch to the verified destination account and Region, create or choose a compatible table, and review import conflict handling before writing. These historical screenshots illustrate the file workflow; current UI layout may differ:

Do not assume a local JSON export has the same format as a native S3 export. Check the format accepted by the chosen importer. A copy into an existing table can overwrite matching records and leave unmatched old records behind, so equal item counts alone do not prove equivalence.

Validate the copy and budget the operation

Before cutover, compare representative records, data types, key coverage and important aggregate totals. Test every required index query with the destination application's role. Review import errors or script failures, and confirm that table settings and ongoing protections have been applied.

In US East (N. Virginia), a full export costs $0.10 per GB of table data plus LSIs, import costs $0.15 per GB of uncompressed source data, and restore costs $0.15 per GB restored. These billing bases are different, so do not blindly add export and import rates against one size. Include S3 storage and requests, transfer, KMS and destination table costs; current rates are on DynamoDB pricing.

For an online migration, capture changes before the initial copy, retain them until the load completes, apply them in a safe order and reconcile deletes. Stop or fence writes for the final cutover if required. Keep the original table and recovery point until the destination's correctness and rollback procedure are verified.