AWS SDK for JavaScript to Rust (Rusoto) Converter

How to convert AWS SDK JavaScript code to Rust

To convert AWS SDK JavaScript code to Rust, paste it above and press Convert to Rust. Each client becomes a Rusoto client for a Region, each parameter object becomes a request struct with ..Default::default(), and await ….promise() becomes .await? inside a Tokio runtime. Then add the crates and run cargo build.

1. Add your JavaScript or TypeScriptPaste it into the AWS SDK (JS/TS) editor, use Paste or Open file (.js, .mjs, .cjs, .jsx, .ts, .tsx or .txt, up to 500 KB), or drop a file onto the editor. Sample loads an S3-to-SQS notifier.
2. Let the secret check runBefore the code leaves your browser, the page scans it for AWS access keys, secret keys, private keys and common API tokens. If it finds one, it highlights the match so you can replace it with a placeholder.
3. Convert to RustClick Convert to Rust or press Ctrl + Enter. The Rust code streams in, and Stop cancels it. Keep each conversion to one function or module; the limit is 60,000 characters.
4. Review the RustLook at every unwrap() and expect(), and at how optional response fields are handled. Copy the code or download it as main.rs.
5. Add crates and buildAdd rusoto_core, one rusoto_* crate per service and tokio to Cargo.toml, then run cargo build and fix whatever the compiler reports.

When converting JavaScript AWS code to Rust helps

Teams port AWS code from Node.js to Rust to get a single compiled binary, predictable memory use, or a Lambda function that runs on the OS-only provided.al2023 runtime. The hard part isn't the AWS logic, which stays the same, but expressing it with Rust's types: request structs, Option fields, Result errors and an async runtime.

This converter produces Rusoto code. Rusoto is in maintenance mode: its maintainers only review dependency bumps and obvious bug fixes. That makes the output a good fit if you maintain an existing Rusoto codebase. For new projects, the official AWS SDK for Rust is generally available, and the converted code still shows you which operations, fields and error paths you need, since both SDKs call the same AWS APIs.

If Rust isn't a hard requirement, the JavaScript to boto3 converter or the boto3 to Go converter may get you to a working port faster.

How JavaScript AWS SDK code maps to Rusoto

Rusoto has one crate per service, such as rusoto_s3 and rusoto_sqs. You create a client for a region, like S3Client::new(Region::EuWest1), and call methods that take a request struct. A parameter object such as { Bucket, Prefix } becomes ListObjectsV2Request { bucket, prefix: Some(...), ..Default::default() }, with snake_case fields and Option for anything AWS treats as optional.

Every call is async and returns a Result, so the converted code runs on Tokio and uses ? where JavaScript used try/catch. Response fields are Options as well, so a JavaScript default like const { Contents = [] } becomes resp.contents.unwrap_or_default(). Methods live on service traits such as S3 and Sqs, which must be imported for the calls to compile.

Key features

• Request structs built for youParameter objects become Rusoto request structs with snake_case fields, Some(...) for optional values and ..Default::default() for the rest.
• Async Rust on TokioPromise chains and await become .await? calls, with a #[tokio::main] entry point when the input has top-level code.
• Errors as Resulttry/catch and .catch() handlers become Result returns, so failures surface through ? instead of exceptions.
• Optional fields handledResponse values that JavaScript read directly are unwrapped with defaults or pattern matching, which you can tighten where it matters.
• Flags what doesn't translateWhen JavaScript behavior has no direct Rust equivalent, the output includes a TODO: comment.
• Checked for secrets firstThe page scans for access keys, secret keys, private keys and tokens in your browser before sending your code.
• Download as main.rsCopy the result or download it as main.rs, ready to drop into a Cargo project.

Examples: JavaScript AWS SDK code converted to Rusoto

Two conversions that show how Rusoto's types change the shape of the code. Choose Try this example to load the JavaScript into the converter. Your output may differ in structure.

const AWS = require("aws-sdk");
const sns = new AWS.SNS({ region: "us-east-1" });

async function sendAlert(topicArn, message) {
  const res = await sns
    .publish({ TopicArn: topicArn, Subject: "Build failed", Message: message })
    .promise();
  return res.MessageId;
}

use rusoto_core::Region;
use rusoto_sns::{PublishInput, Sns, SnsClient};

async fn send_alert(
    topic_arn: &str,
    message: &str,
) -> Result<Option<String>, Box<dyn std::error::Error>> {
    let sns = SnsClient::new(Region::UsEast1);
    let res = sns
        .publish(PublishInput {
            topic_arn: Some(topic_arn.to_string()),
            subject: Some("Build failed".to_string()),
            message: message.to_string(),
            ..Default::default()
        })
        .await?;
    Ok(res.message_id)
}

const AWS = require("aws-sdk");
const dynamodb = new AWS.DynamoDB({ region: "eu-west-1" });

async function getPlan(userId) {
  const { Item } = await dynamodb
    .getItem({ TableName: "users", Key: { userId: { S: userId } } })
    .promise();
  return Item ? Item.plan.S : null;
}

use std::collections::HashMap;

use rusoto_core::Region;
use rusoto_dynamodb::{AttributeValue, DynamoDb, DynamoDbClient, GetItemInput};

async fn get_plan(user_id: &str) -> Result<Option<String>, Box<dyn std::error::Error>> {
    let dynamodb = DynamoDbClient::new(Region::EuWest1);

    let mut key = HashMap::new();
    key.insert(
        "userId".to_string(),
        AttributeValue { s: Some(user_id.to_string()), ..Default::default() },
    );

    let res = dynamodb
        .get_item(GetItemInput {
            table_name: "users".to_string(),
            key,
            ..Default::default()
        })
        .await?;

    Ok(res.item.and_then(|item| item.get("plan").and_then(|v| v.s.clone())))
}

Tips for better results

• Use matching crate versions. rusoto_core and every rusoto_* service crate should share one version, and tokio needs the macros and rt-multi-thread features for #[tokio::main].
• Convert one function at a time. Smaller inputs give the converter room to get Rust's stricter types right, and compiler errors stay easy to trace.
• Decide how to handle missing values. Replace unwrap() and expect() on response fields with explicit handling before the code touches production data.
• Be explicit about the region. JavaScript clients often read it from the environment. In Rusoto, pass a Region variant, or use Region::default(), which reads AWS_DEFAULT_REGION or AWS_REGION.
• Add serde for JSON. JSON.stringify and JSON.parse become serde_json calls, which need the serde and serde_json crates.

Common mistakes when porting to Rusoto

• Forgetting the service trait import. Methods like list_objects_v2 are defined on the S3 trait, so use rusoto_s3::S3; is needed or the call won't compile.
• Calling async code without a runtime. Rusoto futures need Tokio. A plain fn main can't .await them.
• Mixing crate versions. A rusoto_s3 built against a different rusoto_core version produces confusing type errors.
• Assuming fields are plain values. Most response fields are Options. Code that reads obj.key as a String won't compile.
• Starting a new project on Rusoto without checking. For new code, compare with the official AWS SDK for Rust first. It's supported by AWS and receives new service features.

Frequently asked questions

Related tools and next steps

• AWS SDK JavaScript to boto3Port the same AWS logic to Python instead.
• Boto3 to AWS SDK for GoAnother compiled target, if Go suits your team better than Rust.
• AWS SDK v2 to v3 converterKeep the JavaScript version current while you port.
• All AWS code convertersSDK, infrastructure-as-code and IAM tools in one place.
• How ChatWithCloud worksAsk questions about your live AWS resources in plain English.