Boto3 to Go Converter for the AWS SDK for Go v2

How to convert boto3 code to Go

To convert boto3 code to Go, paste the Python above and press Convert to Go. The converter loads configuration with config.LoadDefaultConfig, creates clients with NewFromConfig, turns each call into a method that takes a context.Context and an input struct, and checks the returned error. Then run go mod tidy, go vet and go build.

1. Add your boto3 codePaste into the Python (boto3) editor, open a .py file up to 500 KB, or drag one in. Sample loads a script that pages through the top-level prefixes of an S3 bucket and saves them to DynamoDB.
2. Let the secret check runAccess keys, secret keys, private keys and API tokens are detected in your browser before the code is sent, so you can swap them for placeholders first.
3. Convert to GoPress Convert to Go or Ctrl + Enter. The Go code streams in and can be stopped at any point. Keep each conversion under 60,000 characters.
4. Review the GoStart with error handling: every err should be dealt with, and paginator loops should stop when a page fails. Then resolve any TODO: comments and download the file as main.go.
5. Build itInside a Go module (go mod init if you don't have one), run go mod tidy to fetch the SDK modules, then go vet ./... and go build. The compiler catches import clashes and type mismatches before anything runs.

Why port boto3 scripts to Go

A boto3 script needs a Python runtime and its installed packages everywhere it runs. The Go version compiles to one executable, which is easy to ship as a CLI, copy into a small container image, or run on Lambda's provided.al2023 runtime as a binary named bootstrap. Teams also move scripts to Go when the rest of their platform tooling is already written in it.

Porting by hand is tedious because Go spells out everything Python leaves implicit: pointer fields, a context on every call, typed DynamoDB attribute values and an error check after each request. The converter writes that scaffolding and keeps your function structure, so review time goes on behavior rather than boilerplate.

The output targets the AWS SDK for Go v2, the version AWS recommends. Version 1 reached end-of-support on July 31, 2025, so there's no reason to port new code to it. If your team writes TypeScript instead, the boto3 to AWS SDK v3 converter does the same job for Node.js.

How boto3 maps to the AWS SDK for Go v2

The Go SDK starts from a shared configuration: cfg, err := config.LoadDefaultConfig(ctx) reads credentials and region the same way boto3 does, from environment variables, ~/.aws profiles or an IAM role. Each service then gets a client with s3.NewFromConfig(cfg). See configuring the Go SDK for the options.

Calls take a context.Context and an input struct, and return an output plus an error: out, err := client.ListObjectsV2(ctx, &s3.ListObjectsV2Input{Bucket: aws.String(bucket)}). Optional fields are pointers, so string and number values are wrapped with helpers like aws.String and aws.Int32. boto3 paginators become Go paginators such as s3.NewListObjectsV2Paginator with a HasMorePages loop.

Python exceptions become returned errors. To check for a specific AWS error, the Go SDK uses errors.As with typed errors from each service's types package, or the generic smithy.APIError interface for the error code. The AWS SDK for Go v2 developer guide has examples for each service.

boto3 vs AWS SDK for Go v2: quick reference

Operation and field names match, because both SDKs are generated from the same AWS API definitions. It's the code around each call that changes.

What the converter handles

• Config and clients the Go wayOne config.LoadDefaultConfig call, then a client per service with NewFromConfig. Credentials and region resolve the way boto3 resolves them.
• Paginators become Go paginatorsget_paginator loops turn into NewXxxPaginator with HasMorePages and NextPage.
• Pointers handledInput fields are wrapped with aws.String, aws.Int32 and friends, and output fields are read back with helpers such as aws.ToString.
• Typed DynamoDB attributesLow-level put_item dictionaries become types.AttributeValueMemberS and related attribute types.
• Errors returned, not raisedPython exceptions become error values checked after each call, and anything without a direct Go equivalent gets a TODO: comment.
• Secret check firstAWS keys and tokens in your Python are flagged in the browser before the code is sent.
• Ready to downloadStream the Go as it's written, then copy it or download it as main.go.

Examples: boto3 code converted to Go

Three boto3 patterns and idiomatic Go for the AWS SDK for Go v2. Choose Try this example to load the Python into the converter. The converter's output may be structured differently, for example building clients inside the function.

import boto3

s3 = boto3.client("s3")


def read_config(bucket: str, key: str) -> str:
    obj = s3.get_object(Bucket=bucket, Key=key)
    return obj["Body"].read().decode("utf-8")

package main

import (
	"context"
	"io"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/s3"
)

func readConfig(ctx context.Context, client *s3.Client, bucket, key string) (string, error) {
	out, err := client.GetObject(ctx, &s3.GetObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(key),
	})
	if err != nil {
		return "", err
	}
	defer out.Body.Close()

	data, err := io.ReadAll(out.Body)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

import boto3

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


def save_event(event_id: str, kind: str, count: int) -> None:
    table.put_item(Item={"id": event_id, "kind": kind, "count": count})

package main

import (
	"context"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
)

type Event struct {
	ID    string `dynamodbav:"id"`
	Kind  string `dynamodbav:"kind"`
	Count int    `dynamodbav:"count"`
}

func saveEvent(ctx context.Context, client *dynamodb.Client, e Event) error {
	item, err := attributevalue.MarshalMap(e)
	if err != nil {
		return err
	}
	_, err = client.PutItem(ctx, &dynamodb.PutItemInput{
		TableName: aws.String("events"),
		Item:      item,
	})
	return err
}

import boto3
from botocore.exceptions import ClientError

s3 = boto3.client("s3")


def object_exists(bucket: str, key: str) -> bool:
    try:
        s3.head_object(Bucket=bucket, Key=key)
        return True
    except ClientError as err:
        if err.response["Error"]["Code"] == "404":
            return False
        raise

package main

import (
	"context"
	"errors"

	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/aws-sdk-go-v2/service/s3/types"
)

func objectExists(ctx context.Context, client *s3.Client, bucket, key string) (bool, error) {
	_, err := client.HeadObject(ctx, &s3.HeadObjectInput{
		Bucket: aws.String(bucket),
		Key:    aws.String(key),
	})
	if err == nil {
		return true, nil
	}
	var notFound *types.NotFound
	if errors.As(err, &notFound) {
		return false, nil
	}
	return false, err
}

Tips for better results

• Run go mod tidy. The output imports github.com/aws/aws-sdk-go-v2/config and one module per service. Tidy fetches them all and removes what isn't used.
• Check pointer handling. Reading output fields often means dereferencing pointers. Use aws.ToString and similar helpers so nil values don't panic.
• Use the DynamoDB attributevalue package. For typed items, feature/dynamodb/attributevalue marshals Go structs, which is cleaner than building AttributeValue maps by hand.
• Pass context through. Keep a ctx parameter in your functions so callers can set timeouts and cancel long-running calls.
• Handle every error. Replace any ignored errors (_) in the output with real handling before you rely on the code.

Common mistakes when porting boto3 to Go

• Colliding types imports. Every service has a package named types, so importing service/s3/types and service/dynamodb/types in one file won't compile until you alias one, for example ddbtypes. Converted output can include this clash, so build before you trust it.
• Continuing after a paginator error. If NextPage fails, return or break. A continue asks for the same page again, and again, because the paginator only advances after a successful call.
• Dereferencing nil pointers. Output fields such as obj.Key are pointers. Read them with aws.ToString or check for nil instead of writing *obj.Key.
• Using context.Background() everywhere. Accept a ctx parameter so callers, including a Lambda handler, can cancel calls or give them a deadline.
• Leaving response bodies open. GetObject returns a stream. After checking the error, defer out.Body.Close().
• Mixing SDK for Go v1 and v2. Imports from github.com/aws/aws-sdk-go (v1) don't work with aws-sdk-go-v2 clients; v1 sessions and v2 config are different types.

Frequently asked questions

Related tools and next steps

• IAM policy from Go codeGet a least-privilege policy for the AWS calls in your new Go file.
• IAM policy from Python codeSee what the original boto3 script needs, to compare permissions.
• Boto3 to AWS SDK v3 converterPort the same script to TypeScript and Node.js instead.
• AWS SDK JS to boto3 converterBring JavaScript AWS code over to Python.
• All AWS code convertersSDK, infrastructure-as-code and IAM policy tools in one place.