Boto3 to AWS SDK v3 Converter: Python to TypeScript

How to convert boto3 code to AWS SDK v3

To convert boto3 code to AWS SDK for JavaScript v3, paste your Python into the editor above and press Convert to TypeScript. Each boto3.client() becomes a v3 client, each call becomes await client.send(new SomethingCommand(params)), and functions become async. Then install the imported @aws-sdk/* packages and type-check the result.

1. Add your boto3 codePaste a Python module into the Python (boto3) editor, use Open file for a .py file up to 500 KB, or drag the file onto the editor. Sample loads a function that reads a DynamoDB item and archives it to S3.
2. Let the secret check runBefore anything is sent, the page scans for AWS access keys, secret keys, private keys and common API tokens. Scripts often set aws_access_key_id inline; replace those with placeholders when the check flags them.
3. Convert to TypeScriptClick Convert to TypeScript or press Ctrl + Enter. The TypeScript streams into the right-hand editor, and you can stop it early. One conversion takes up to 60,000 characters, so send one module at a time.
4. Compare it with the PythonCheck that each boto3 call has a matching command, that every try block wraps the same calls as the original try/except, and that any TODO: comments are resolved. Then Copy it or Download it as converted.ts.
5. Install and type-checkRun npm install for each @aws-sdk/* package the file imports, then npx tsc --noEmit and your tests. The compiler catches misspelled parameter names that Python would only reject at runtime.

Why move boto3 code to TypeScript and SDK v3

Teams usually port boto3 code when the logic has to live somewhere Python doesn't: a Node.js API, a TypeScript Lambda function that shares types with a frontend, or a CDK app written in TypeScript. Rewriting it by hand is slow because every call changes shape. Snake_case methods turn into command classes, blocking calls turn into promises, and response dictionaries turn into typed objects.

The converter does that mechanical part one module at a time and keeps your function structure and comments where they still apply, so the TypeScript reads like the Python you started with. The review work stays with you: error handling, pagination and data types, where the two SDKs genuinely differ.

SDK v3 is the version to target. It's the supported AWS SDK for JavaScript, it's included in the Lambda Node.js 18 and later runtimes, and you install only the service clients you use. If the destination project is still pinned to the old aws-sdk package, use the boto3 to SDK v2 converter instead.

How boto3 maps to AWS SDK for JavaScript v3

Each boto3 client call becomes a v3 command sent through a client. s3.put_object(Bucket=b, Key=k, Body=data) becomes await s3.send(new PutObjectCommand({ Bucket: b, Key: k, Body: data })). The parameter names are identical because both SDKs follow the AWS API, but every call becomes asynchronous, so the converted functions are async and use await.

boto3's resource interface needs the most translation. A DynamoDB Table resource maps best to DynamoDBDocumentClient from @aws-sdk/lib-dynamodb, which accepts plain JavaScript values. boto3 paginators become v3 helpers such as paginateScan or paginateListObjectsV2, used with for await.

Error handling changes from except ClientError and reading err.response["Error"]["Code"] to try/catch with err.name or service exception classes such as NoSuchKey. The AWS SDK for JavaScript v3 developer guide covers each of these patterns.

boto3 vs AWS SDK v3: quick reference

The patterns the converter rewrites most often. Parameter names don't change, because both SDKs are generated from the same AWS API definitions.

What the converter handles

• Clients and resourcesBoth boto3.client() and boto3.resource() code converts. Resource calls become the matching commands, and DynamoDB Table objects become DynamoDBDocumentClient.
• Async by defaultFunctions that call AWS become async, every SDK call is awaited, and a script's if __name__ == "__main__" block becomes a top-level call.
• Typed outputParameters and return values get TypeScript types, so the compiler checks your v3 input objects against the SDK's own type definitions.
• Your logic stays putFunction structure and business logic stay as they were, names follow TypeScript's camelCase convention, and comments carry over where they still apply.
• Gaps marked with TODOWhen a boto3 feature has no direct v3 equivalent, the converter writes the closest version and adds a TODO: comment saying what to check.
• Secret check firstAWS keys, private keys and common API tokens are detected in your browser before the code is sent.
• Stream, copy, downloadWatch the TypeScript arrive, stop early if you need to, then copy it or download converted.ts.
• Free to useNo signup needed. A free account raises the limit to 200 conversions a day and lists recent ones on your dashboard.

Examples: boto3 code converted to TypeScript

Three everyday boto3 patterns and the SDK v3 TypeScript they should become. Choose Try this example to load the Python into the converter. Your output may differ in naming and formatting.

import boto3

s3 = boto3.client("s3")


def total_size(bucket: str, prefix: str = "") -> int:
    """Add up the size of every object under a prefix."""
    size = 0
    paginator = s3.get_paginator("list_objects_v2")
    for page in paginator.paginate(Bucket=bucket, Prefix=prefix):
        for obj in page.get("Contents", []):
            size += obj["Size"]
    return size

import { S3Client, paginateListObjectsV2 } from "@aws-sdk/client-s3";

const s3 = new S3Client({});

/** Add up the size of every object under a prefix. */
export async function totalSize(bucket: string, prefix = ""): Promise<number> {
  let size = 0;
  const pages = paginateListObjectsV2({ client: s3 }, { Bucket: bucket, Prefix: prefix });
  for await (const page of pages) {
    for (const obj of page.Contents ?? []) {
      size += obj.Size ?? 0;
    }
  }
  return size;
}

import boto3
from botocore.exceptions import ClientError

table = boto3.resource("dynamodb").Table("inventory")


def reserve(sku: str, qty: int) -> bool:
    try:
        table.update_item(
            Key={"sku": sku},
            UpdateExpression="SET stock = stock - :q",
            ConditionExpression="stock >= :q",
            ExpressionAttributeValues={":q": qty},
        )
        return True
    except ClientError as err:
        if err.response["Error"]["Code"] == "ConditionalCheckFailedException":
            return False
        raise

import { DynamoDBClient, ConditionalCheckFailedException } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, UpdateCommand } from "@aws-sdk/lib-dynamodb";

const doc = DynamoDBDocumentClient.from(new DynamoDBClient({}));

export async function reserve(sku: string, qty: number): Promise<boolean> {
  try {
    await doc.send(
      new UpdateCommand({
        TableName: "inventory",
        Key: { sku },
        UpdateExpression: "SET stock = stock - :q",
        ConditionExpression: "stock >= :q",
        ExpressionAttributeValues: { ":q": qty },
      })
    );
    return true;
  } catch (err) {
    if (err instanceof ConditionalCheckFailedException) {
      return false;
    }
    throw err;
  }
}

import boto3

s3 = boto3.client("s3")


def download_link(bucket: str, key: str) -> str:
    return s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": bucket, "Key": key},
        ExpiresIn=3600,
    )

import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

const s3 = new S3Client({});

export function downloadLink(bucket: string, key: string): Promise<string> {
  return getSignedUrl(s3, new GetObjectCommand({ Bucket: bucket, Key: key }), {
    expiresIn: 3600,
  });
}

Tips for better results

• Send whole functions with their imports. The import boto3 lines and client setup tell the converter which services, and which interface (client or resource), you use.
• Delete hard-coded credentials first. SDK v3 reads the same environment variables, ~/.aws profiles and IAM roles as boto3, so the converted code rarely needs keys in it.
• Create clients once. Keep them at module level, especially in Lambda, where they're reused across invocations instead of rebuilt per request.
• Type-check before you run. npx tsc --noEmit flags wrong parameter names and misused responses faster than a test run.
• Port your tests too. Tests built on moto or botocore.stub.Stubber need a JavaScript replacement such as aws-sdk-client-mock.

Common mistakes when porting boto3 to TypeScript

• Forgetting await. boto3 calls return data; v3 calls return promises. A missing await leaves you holding a pending promise, and its errors escape your try block.
• Changing what a try block covers. Compare each try/catch with the original try/except. A single try that now also wraps an S3 write turns a loud failure into a quiet return false.
• Reading an S3 Body like a Python stream. There's no .read() in v3. Use await Body.transformToString() or transformToByteArray().
• Trusting DynamoDB number types. boto3's resource returns Decimal; the DocumentClient returns JavaScript numbers, which lose precision above 2⁵³. Set unmarshallOptions: { wrapNumbers: true } for very large values.
• Looking for err.response. v3 errors expose err.name and err.$metadata.httpStatusCode; there's no response dictionary.
• Installing only @aws-sdk/client-dynamodb. Code that uses DynamoDBDocumentClient also needs @aws-sdk/lib-dynamodb.

Frequently asked questions

Related tools and next steps

• IAM policy from TypeScript codeDraft a least-privilege policy for the AWS calls in your converted file.
• AWS SDK JS to boto3 converterGo the other way, from JavaScript or TypeScript back to Python.
• Boto3 to Go converterPort the same script to the AWS SDK for Go v2 instead.
• AWS SDK v2 to v3 converterUpgrade older aws-sdk v2 code living in the same codebase.
• All AWS code convertersSDK, infrastructure-as-code and IAM policy tools in one place.
• How ChatWithCloud worksAsk questions about your live AWS account in plain English.