Boto3 to AWS SDK v2 Converter: Python to TypeScript

How to convert boto3 code to AWS SDK v2

To convert boto3 code to AWS SDK for JavaScript v2, paste the Python above and press Convert to TypeScript. Each boto3 client becomes an AWS service object such as new AWS.SQS(), snake_case methods become camelCase, and every call ends in .promise() and is awaited. Then test it inside the v2 project it's meant for.

1. Add your boto3 codePaste Python into the Python (boto3) editor, open a .py file up to 500 KB, or drop one onto the editor. Sample loads a small job that forwards SQS messages to an SNS topic.
2. Check for secretsBefore anything leaves the page, it looks for AWS keys, private keys and common API tokens. Swap any it finds for placeholders; the v2 SDK reads credentials from the same places boto3 does.
3. Convert to TypeScriptClick Convert to TypeScript or press Ctrl + Enter, and watch the output stream in. Stop it early if you pasted the wrong file. The limit is 60,000 characters per conversion.
4. Review against the originalMatch each boto3 call to its v2 method, and look closely at fallback values and pagination loops. Resolve any TODO: comments, then copy the result or download converted.ts.
5. Drop it into the v2 projectMake sure the project depends on aws-sdk v2 (npm install aws-sdk@2), compile with tsc and run your tests. On the Node.js 18 and later Lambda runtimes, bundle aws-sdk with the function.

When converting boto3 to SDK v2 still makes sense

Most of the time it doesn't. v2 no longer gets updates or security fixes, and new code written against it is code you'll migrate again. But some teams can't change SDKs mid-project: a service may share v2 wrappers, helpers and mocks across dozens of files, or a release freeze may rule out a dependency change. If a Python job has to move into that codebase now, matching its SDK keeps the change small.

This converter writes TypeScript that sits comfortably next to existing aws-sdk code, with AWS.* service objects, v2 request types and .promise() calls. When the project is ready to upgrade, the AWS SDK v2 to v3 converter can take the same file forward.

Starting something new? Use the boto3 to SDK v3 converter. v3 is included in the current Lambda Node.js runtimes and won't need a second migration.

How boto3 maps to AWS SDK for JavaScript v2

In v2, each boto3 call becomes a method on a service client followed by .promise(). sqs.receive_message(QueueUrl=url, MaxNumberOfMessages=10) becomes await sqs.receiveMessage({ QueueUrl: url, MaxNumberOfMessages: 10 }).promise(). Method names change to camelCase, while parameter names stay the same because both SDKs follow the AWS API.

boto3's DynamoDB Table resource maps to AWS.DynamoDB.DocumentClient, which also accepts native values. Paginators become loops that pass NextToken or ContinuationToken into the next request, and except ClientError becomes a catch that checks err.code.

Credentials and region resolve much as they do in boto3: environment variables, the shared ~/.aws files, then the IAM role of the machine or function. The AWS SDK for JavaScript v2 developer guide still documents the v2 APIs.

boto3 vs AWS SDK v2: quick reference

How the everyday boto3 patterns look in aws-sdk v2. Parameters keep their AWS names; method names and error handling change.

What the converter handles

• Service objects and camelCase methodsboto3.client("sqs") becomes new AWS.SQS() and receive_message becomes receiveMessage, with the parameters unchanged.
• Promises instead of callbacksCalls use .promise() with await, so the TypeScript reads top to bottom like the Python did, instead of nesting v2 callbacks.
• Fits existing v2 codeOutput uses the AWS namespace and the type definitions bundled with aws-sdk, the style most v2 codebases already follow.
• DynamoDB tables mappedboto3 Table resources become AWS.DynamoDB.DocumentClient, which takes plain values instead of typed attribute maps.
• Gaps flagged with TODOAnything without a clean v2 equivalent gets the closest version plus a TODO: comment saying what to verify.
• Secret check before sendingKeys and tokens in your Python are caught in the browser, before the code goes anywhere.
• Copy or downloadCopy the TypeScript, or download it as converted.ts. Wrap long lines to read them without scrolling.

Examples: boto3 code converted for SDK v2

Three boto3 patterns and the aws-sdk v2 TypeScript they should become. Choose Try this example to load the Python into the converter. Your output may be formatted differently, or use another import style.

import boto3

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


def get_customer(customer_id: str):
    response = table.get_item(Key={"id": customer_id})
    return response.get("Item")

import * as AWS from "aws-sdk";

const docClient = new AWS.DynamoDB.DocumentClient();

export async function getCustomer(customerId: string) {
  const response = await docClient
    .get({ TableName: "customers", Key: { id: customerId } })
    .promise();
  return response.Item;
}

import boto3

s3 = boto3.client("s3")


def list_keys(bucket: str) -> list:
    keys = []
    paginator = s3.get_paginator("list_objects_v2")
    for page in paginator.paginate(Bucket=bucket):
        keys.extend(obj["Key"] for obj in page.get("Contents", []))
    return keys

import * as AWS from "aws-sdk";

const s3 = new AWS.S3();

export async function listKeys(bucket: string): Promise<string[]> {
  const keys: string[] = [];
  let token: string | undefined;
  do {
    const page = await s3
      .listObjectsV2({ Bucket: bucket, ContinuationToken: token })
      .promise();
    for (const obj of page.Contents ?? []) {
      if (obj.Key) keys.push(obj.Key);
    }
    token = page.NextContinuationToken;
  } while (token);
  return keys;
}

import boto3
from botocore.exceptions import ClientError

ssm = boto3.client("ssm")


def get_setting(name: str, default: str) -> str:
    try:
        return ssm.get_parameter(Name=name)["Parameter"]["Value"]
    except ClientError as err:
        if err.response["Error"]["Code"] == "ParameterNotFound":
            return default
        raise

import * as AWS from "aws-sdk";

const ssm = new AWS.SSM();

export async function getSetting(name: string, fallback: string): Promise<string> {
  try {
    const result = await ssm.getParameter({ Name: name }).promise();
    return result.Parameter!.Value!;
  } catch (err) {
    if ((err as AWS.AWSError).code === "ParameterNotFound") {
      return fallback;
    }
    throw err;
  }
}

Tips for better results

• Confirm it's really v2 you need. If the target project doesn't depend on aws-sdk yet, use the v3 converter instead.
• Match the project's import style. Swap import * as AWS for whatever the codebase already uses, such as import AWS = require("aws-sdk") or per-service imports like aws-sdk/clients/sqs.
• Test pagination with real volume. Run each loop against more than one page of results to confirm it collects everything and then stops.
• Keep credentials out of the code. Remove hard-coded keys; v2 reads environment variables, shared config files and IAM roles, just like boto3.
• Log the file for your v3 migration. Every v2 file you add is one more to upgrade, so note it where you track that work.

Common mistakes with boto3 to SDK v2 ports

• Dropping .promise(). Without it, await hands back an AWS.Request object instead of the response, and nothing is sent.
• Hiding missing values behind defaults. Output such as msg.ReceiptHandle ?? "" satisfies the compiler but sends an empty value to AWS when the field is missing. Decide whether that case should throw instead.
• Assuming Lambda includes v2. The Node.js 18 and later runtimes only ship v3, so a v2 function fails with Cannot find module 'aws-sdk' unless you bundle it.
• Forgetting the table name. boto3's Table resource carries its name; every DocumentClient call needs TableName in its params.
• Mixing SDK versions in one module. Don't import @aws-sdk/* clients next to aws-sdk unless you're deliberately migrating. Clients, errors and test mocks differ between the two.

Frequently asked questions

Related tools and next steps

• Boto3 to AWS SDK v3 converterThe recommended target for new TypeScript code.
• AWS SDK v2 to v3 converterMove the converted file to v3 when the project is ready.
• AWS SDK v3 to v2 converterBackport v3 snippets into the same v2 codebase.
• AWS SDK JS to boto3 converterConvert JavaScript AWS code back to Python.
• All AWS code convertersSDK, infrastructure-as-code and IAM policy tools in one place.