DeepSeek in Amazon Bedrock: Models, Pricing, APIs, and Setup Guide

Last updated: May 5, 2026

DeepSeek in Amazon Bedrock refers to using DeepSeek foundation models through AWS’s managed Amazon Bedrock service instead of deploying and operating the models yourself. As of this update, AWS documentation lists DeepSeek V3.2, DeepSeek-V3.1, and DeepSeek-R1 as available DeepSeek models in Amazon Bedrock. DeepSeek V3.2 and DeepSeek-V3.1 support Invoke, Converse, and Chat Completions, while DeepSeek-R1 supports Invoke and Converse but not Chat Completions. Always verify the exact model ID, region, endpoint, and price in your Amazon Bedrock console before production deployment.

What Is DeepSeek in Amazon Bedrock?

Amazon Bedrock is a fully managed AWS service that provides secure, enterprise-grade access to foundation models so teams can build and scale generative AI applications without managing model infrastructure directly.

DeepSeek in Amazon Bedrock gives AWS teams access to DeepSeek models through Bedrock’s APIs, governance controls, security features, service tiers, and integration points such as IAM, CloudTrail, Guardrails, Agents, Flows, and model evaluation where supported. The main reason DeepSeek matters in Bedrock is its usefulness for workloads that require reasoning, code generation, math, technical analysis, and multi-step problem solving.

This is not only about calling a model. For production teams, the value is being able to run DeepSeek inside an AWS operating model: access control, regional deployment decisions, cost monitoring, security review, and responsible AI controls.

Which DeepSeek Models Are Available in Amazon Bedrock?

AWS currently documents three DeepSeek models in Amazon Bedrock: DeepSeek V3.2, DeepSeek-V3.1, and DeepSeek-R1. AWS describes V3.2 as a mixture-of-experts model with improved reasoning, coding, and instruction following; V3.1 as a 685B parameter mixture-of-experts model for coding, math, and general reasoning; and R1 as a reasoning model that uses chain-of-thought for complex math, coding, and logic problems.

Model	Best for	Context window	Max output tokens	Reasoning support	API support	Model ID / endpoint notes	Recommended use case
DeepSeek V3.2	Reasoning, coding, instruction following, general enterprise assistants	164K tokens	8K	Strong reasoning behavior; AWS model card describes improved reasoning	Invoke, Converse, Chat Completions	deepseek.v3.2 for both bedrock-runtime and bedrock-mantle	New applications that need long context and OpenAI-compatible Chat Completions
DeepSeek-V3.1	Coding, math, general reasoning, hybrid thinking/non-thinking usage	128K tokens	8K	Hybrid thinking and direct-answer style; model is 685B parameter MoE	Invoke, Converse, Chat Completions	deepseek.v3-v1:0 on bedrock-runtime; deepseek.v3.1 on bedrock-mantle	Engineering assistants, architecture reasoning, data analysis, agentic workflows
DeepSeek-R1	Math, code, logic, chain-of-thought-style reasoning workloads	128K tokens	8K	Reasoning supported	Invoke, Converse; no Chat Completions	deepseek.r1-v1:0; geo inference profile ID may be us.deepseek.r1-v1:0	Deep reasoning tasks where Chat Completions compatibility is not required

DeepSeek V3.2 has a 164K token context window, 8K max output, text input/output, support for Invoke, Converse, and Chat Completions, and the model ID deepseek.v3.2 for both bedrock-runtime and bedrock-mantle.

DeepSeek-V3.1 has a 128K token context window, 8K max output, support for Invoke, Converse, and Chat Completions, and different model IDs depending on endpoint: deepseek.v3-v1:0 for bedrock-runtime and deepseek.v3.1 for bedrock-mantle.

DeepSeek-R1 has a 128K token context window, 8K max output, reasoning support, and supports Invoke and Converse; AWS lists deepseek.r1-v1:0 for bedrock-runtime and us.deepseek.r1-v1:0 as the US geo inference ID.

Important: Model availability varies by AWS Region. The R1 model card shows geo cross-Region inference across US Regions, while V3.2 and V3.1 show broader in-Region availability. Always confirm the model in your Bedrock console and region before coding against a model ID.

Why Use DeepSeek Through Amazon Bedrock Instead of Calling DeepSeek Directly?

Using DeepSeek through Amazon Bedrock is attractive when your organization already runs workloads on AWS and needs centralized governance, security, observability, and billing. Bedrock also gives teams a unified way to experiment with multiple foundation models and choose the best fit for performance, cost, and deployment requirements.

Key advantages include:

Benefit	Why it matters
Unified AWS API	Developers can integrate DeepSeek through familiar Bedrock Runtime APIs.
Managed or serverless access	Fully managed Bedrock models reduce infrastructure work compared with self-hosting.
IAM integration	Access can be controlled using AWS identity and permission boundaries.
Guardrails	Teams can apply configurable safety and privacy controls to prompts and responses.
Model evaluation	AWS provides model and RAG evaluation workflows to compare performance and quality.
Private networking	AWS PrivateLink can keep traffic private between Amazon VPC and Amazon Bedrock.
Provider isolation	AWS states that inputs and outputs are not shared with model providers.
Centralized governance	CloudTrail, CloudWatch, cost controls, and AWS account policies fit enterprise workflows.

AWS states that Amazon Bedrock content is not used to improve base models, is not shared with model providers, and is encrypted in transit and at rest; AWS also notes that PrivateLink can be used to establish private connectivity from VPC to Bedrock.

Balanced note: Amazon Bedrock improves enterprise controls, but it does not remove the need for security review, data classification, least-privilege IAM, prompt testing, model evaluation, human review for high-risk use cases, monitoring, and cost governance.

DeepSeek in Amazon Bedrock: API Options Explained

AWS documents the Amazon Bedrock API compatibility family as including Invoke, Converse, ConverseStream, and OpenAI-compatible APIs such as Chat Completions where supported.

API option	Best for	DeepSeek support	Notes
InvokeModel / Invoke API	Low-level model invocation, direct request body control	V3.2, V3.1, R1	Useful when you want direct model-specific payload control.
Converse API	Multi-turn chat applications	V3.2, V3.1, R1	Recommended for model-agnostic chat apps. AWS describes Converse as a unified interface for synchronous multi-turn conversations.
ConverseStream	Streaming responses	Supported where model supports response streaming	Use when users need incremental output.
Chat Completions API via bedrock-mantle	OpenAI-compatible integrations	V3.2 and V3.1; not R1	Best when migrating existing OpenAI SDK-based applications.
Bedrock console playground	Testing prompts before code	Supported for available models	Good for quick validation and stakeholder demos.

DeepSeek V3.2 and V3.1 support Chat Completions through bedrock-mantle, but DeepSeek-R1 does not. AWS’s API compatibility table shows V3.2 and V3.1 as supporting Invoke, Converse, and Chat Completions, while R1 supports Invoke and Converse only.

How to Get Started with DeepSeek in Amazon Bedrock

Prerequisites

You need:

• An AWS account.
• Amazon Bedrock access in a region where your selected DeepSeek model is available.
• IAM permissions for Bedrock and Bedrock Runtime.
• Python and boto3.
• AWS CLI, optional but useful.
• Standard AWS credentials for bedrock-runtime, or a Bedrock API key for supported API-key workflows.
• Amazon Bedrock Guardrails, optional but recommended.

AWS documents Bedrock API keys, including short-term and long-term keys, but recommends restricting API keys to exploration and switching to short-term credentials for applications with stronger security requirements.

Step-by-step setup

1. Open the Amazon Bedrock console.
2. Check the model catalog or model cards for DeepSeek.
3. Choose the model and AWS Region.
4. Test a prompt in the Bedrock Playground.
5. Invoke the model with Python using boto3 or OpenAI-compatible Chat Completions where supported.
6. Add Guardrails for harmful content, denied topics, sensitive information, and grounding checks where relevant.
7. Monitor input tokens, output tokens, latency, errors, and cost.

AWS’s DeepSeek-R1 launch post shows a console workflow that includes selecting DeepSeek-R1 in the Playground and using “View API request” to access AWS CLI and SDK examples.

Python Example: Invoke DeepSeek-R1 with the Converse API

Use this example for DeepSeek-R1 Amazon Bedrock through the bedrock-runtime endpoint.

import boto3
from botocore.exceptions import ClientError, BotoCoreError

REGION = "us-west-2"

# For DeepSeek-R1, check your Bedrock console.
# Some regions/use cases require the cross-Region inference profile ID:
# "us.deepseek.r1-v1:0"
MODEL_ID = "us.deepseek.r1-v1:0"

client = boto3.client("bedrock-runtime", region_name=REGION)

messages = [
    {
        "role": "user",
        "content": [
            {
                "text": (
                    "Explain the trade-offs between using Amazon Bedrock "
                    "managed models and self-hosting an open-weight model."
                )
            }
        ],
    }
]

try:
    response = client.converse(
        modelId=MODEL_ID,
        messages=messages,
        inferenceConfig={
            "maxTokens": 700,
            "temperature": 0.3,
            "topP": 0.9,
        },
    )

    output_text = response["output"]["message"]["content"][0]["text"]
    print(output_text)

except (ClientError, BotoCoreError, KeyError) as error:
    print(f"Failed to invoke model {MODEL_ID}: {error}")
    raise

Important: For DeepSeek-R1, verify whether your region requires deepseek.r1-v1:0 or a cross-Region inference profile such as us.deepseek.r1-v1:0. AWS’s R1 model card lists both the in-region model ID and the US geo inference ID.

Python Example: Invoke DeepSeek V3.2 with Amazon Bedrock

DeepSeek V3.2 supports both bedrock-runtime and bedrock-mantle. AWS lists deepseek.v3.2 as the model ID for both endpoints.

Option A: Boto3 Converse API

import boto3
from botocore.exceptions import ClientError, BotoCoreError

REGION = "us-east-1"
MODEL_ID = "deepseek.v3.2"

client = boto3.client("bedrock-runtime", region_name=REGION)

messages = [
    {
        "role": "user",
        "content": [
            {
                "text": (
                    "Create a production readiness checklist for deploying "
                    "a customer support chatbot on Amazon Bedrock."
                )
            }
        ],
    }
]

try:
    response = client.converse(
        modelId=MODEL_ID,
        messages=messages,
        inferenceConfig={
            "maxTokens": 900,
            "temperature": 0.2,
            "topP": 0.95,
        },
    )

    print(response["output"]["message"]["content"][0]["text"])

except (ClientError, BotoCoreError, KeyError) as error:
    print(f"Failed to invoke model {MODEL_ID}: {error}")
    raise

Option B: OpenAI-compatible Chat Completions via bedrock-mantle

Use this when you want to adapt an existing OpenAI SDK integration.

export OPENAI_API_KEY="<your-bedrock-api-key>"
export OPENAI_BASE_URL="https://bedrock-mantle.us-east-1.api.aws/v1"

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="deepseek.v3.2",
    messages=[
        {
            "role": "user",
            "content": "Explain how Amazon Bedrock Guardrails can reduce AI application risk."
        }
    ],
)

print(response.choices[0].message.content)

AWS’s V3.2 model card includes Chat Completions sample setup with OPENAI_API_KEY, OPENAI_BASE_URL, the OpenAI SDK, and model="deepseek.v3.2".

AWS CLI Example

Replace the region, model ID, prompt, and output filename.

aws bedrock-runtime invoke-model \
  --region us-east-1 \
  --model-id deepseek.v3.2 \
  --cli-binary-format raw-in-base64-out \
  --body '{
    "messages": [
      {
        "role": "user",
        "content": "Summarize the security benefits of using DeepSeek through Amazon Bedrock."
      }
    ],
    "max_tokens": 700
  }' \
  deepseek-output.json

For DeepSeek-R1, AWS’s launch post shows an AWS CLI pattern using us.deepseek.r1-v1:0 as the model ID for cross-Region inference.

DeepSeek in Amazon Bedrock Pricing

DeepSeek Bedrock pricing depends on model, region, and service tier. For DeepSeek V3.2, AWS’s pricing page currently lists $0.62 per 1M input tokens and $1.85 per 1M output tokens in US East and US West regions under Standard on-demand pricing; other regions have different prices.

Pricing factor	What to check	Why it matters
Model	DeepSeek V3.2, V3.1, or R1	Pricing and API support can differ by model.
Region	Example: US East, US West, Tokyo, London, Sydney	AWS pricing varies by region.
Service tier	Standard, Priority, Flex, Reserved where supported	V3.2 supports Standard, Priority, and Flex; V3.1 and R1 have more limited tier support in current AWS model cards.
Token mix	Input tokens vs output tokens	Output tokens often cost more.
Deployment path	Fully managed Bedrock vs Marketplace vs SageMaker vs EC2	Marketplace, SageMaker, and EC2 paths may include instance or infrastructure charges.

Practical cost example

Assume DeepSeek V3.2 in a US Region at the current Standard on-demand price:

• Input tokens: 100,000
• Output tokens: 25,000
• Input cost: 100,000 / 1,000,000 × $0.62 = $0.062
• Output cost: 25,000 / 1,000,000 × $1.85 = $0.04625
• Estimated total: $0.10825

Cost note: This is only a model-token estimate. It excludes other AWS service charges, logs, storage, networking, Guardrails, Knowledge Bases, Marketplace endpoint costs, SageMaker endpoints, or EC2 infrastructure. Check the official Amazon Bedrock pricing page before production use.

Security, Privacy, and Compliance Considerations

AWS states that Amazon Bedrock does not store or log prompts and completions, does not use prompts and completions to train AWS models, and does not distribute them to third parties. AWS also states that model providers do not have access to Bedrock model deployment accounts.

For production use, apply these controls:

• Use IAM least privilege.
• Use short-term credentials where practical.
• Enable CloudTrail for auditability.
• Use AWS PrivateLink for private connectivity where required.
• Encrypt data in transit and at rest.
• Avoid secrets in prompts, tags, names, metadata, and logs.
• Classify data before sending it to any model.
• Use Guardrails for sensitive information and harmful content.
• Run model evaluation before production release.
• Monitor latency, token usage, refusal behavior, hallucinations, and cost.

AWS recommends protecting credentials, using IAM or IAM Identity Center, using SSL/TLS, setting up CloudTrail logging, and avoiding confidential information in tags and free-form name fields.

Using Amazon Bedrock Guardrails with DeepSeek

Amazon Bedrock Guardrails provides configurable safeguards to help detect and filter undesirable content and protect sensitive information in model inputs and responses. AWS documentation lists major Guardrails components including content filters, denied topics, word filters, sensitive information filters, contextual grounding checks, and Automated Reasoning checks.

Use Guardrails with DeepSeek when you need:

• Content filtering for harmful categories.
• Denied topics for business-specific exclusions.
• Sensitive information filters for PII masking or blocking.
• Word filters for prohibited phrases.
• Contextual grounding checks for RAG-style responses.
• Automated Reasoning checks for policy-based validation.

AWS’s DeepSeek Guardrails blog recommends security controls for DeepSeek-R1 deployments and describes using Guardrails with DeepSeek models across Bedrock Marketplace, SageMaker JumpStart, and Custom Model Import patterns.

Best practice: Test Guardrails before production with real prompts, adversarial prompts, multilingual prompts, edge cases, and expected false positives. A guardrail configuration that is too strict can block useful responses; a configuration that is too loose can miss policy violations.

Deployment Options: Bedrock Managed Models vs Marketplace vs Custom Model Import vs SageMaker

Option	Best for	Infrastructure management	Pricing model	Pros	Cons	Recommended audience
Fully managed DeepSeek model in Amazon Bedrock	Most production apps that want DeepSeek through AWS APIs	Minimal	Token-based / Bedrock tier pricing	Fastest path, unified APIs, IAM, Guardrails support where available	Model and region availability constraints	App developers, cloud architects, platform teams
Amazon Bedrock Marketplace	Specialized models and endpoint-level deployment control	Managed endpoints, but more configuration	Marketplace and endpoint charges may apply	Larger model catalog, deploy selected models on managed endpoints	More operational and cost planning than serverless models	ML platform teams
Amazon Bedrock Custom Model Import	Distilled or customized compatible models	Serverless imported model experience	Custom Model Unit / import-related pricing	Use external customizations with Bedrock tools	Architecture and model support limitations	Teams with custom or distilled models
SageMaker JumpStart	ML teams needing deeper deployment control	More control and more responsibility	Endpoint infrastructure pricing	Strong ML workflow integration	Requires endpoint, quota, and scaling management	ML engineers and research teams
EC2 with Trainium/Inferentia for distilled models	Maximum control and optimization	High	Instance, storage, networking	Full infrastructure control	Highest operational burden	Advanced infra/ML platform teams

Amazon Bedrock Marketplace lets developers discover, subscribe to, and deploy over 100 models on managed endpoints, while still accessing compatible models through Bedrock unified APIs and tools.

Amazon Bedrock Custom Model Import supports distilled Llama versions of DeepSeek-R1, including DeepSeek-R1-Distill-Llama-8B and DeepSeek-R1-Distill-Llama-70B, imported from Amazon S3 or an Amazon SageMaker AI model repository into a managed serverless environment.

AWS also announced DeepSeek-R1 and distilled models through Bedrock Marketplace and SageMaker JumpStart, with distilled versions ranging from 1.5B to 70B parameters.

Best Use Cases for DeepSeek in Amazon Bedrock

Use case	Why DeepSeek fits	Likely model	Watch out for
Code generation and debugging	DeepSeek models are positioned strongly for coding and reasoning	V3.2 or V3.1	Test for insecure code, dependency hallucinations, and licensing concerns.
Technical architecture reasoning	Long-form trade-off analysis benefits from reasoning models	V3.2, V3.1, or R1	Validate recommendations against your architecture standards.
Math and quantitative analysis	R1 is designed for complex math and logic tasks	R1 or V3.2	Do not use without verification for financial, legal, or safety-critical decisions.
Data analysis	Good for explaining patterns and generating analytical steps	V3.2 or V3.1	Keep raw sensitive data out unless approved by policy.
Business decision support	Useful for scenario analysis and structured comparisons	V3.2	Require human approval for material business decisions.
Agentic workflows	V3.1 and V3.2 support client-side tool calling; server-side tool calling is not supported in the cited model cards	V3.1 or V3.2	Test tool boundaries, permissions, and prompt injection resistance.
Multilingual enterprise apps	AWS’s V3.1 launch post highlights broad multilingual capability	V3.1	Evaluate quality in your actual target languages.
RAG applications	DeepSeek can synthesize retrieved material when paired with retrieval	V3.2 or V3.1	Use grounding checks and citations to reduce hallucinations.
Internal developer assistants	Good fit for code review, explanation, and troubleshooting	V3.2 or V3.1	Restrict repository, secret, and credential exposure.

Common Limitations and Troubleshooting

Issue	Likely cause	Fix
Model not visible	Region, access, or account permission issue	Check the Bedrock console, model card, and IAM permissions.
AccessDeniedException	IAM policy missing Bedrock Runtime permission	Add least-privilege actions for the specific model and region.
Wrong model ID	Endpoint-specific IDs differ	Use deepseek.v3.2, deepseek.v3-v1:0, deepseek.v3.1, or deepseek.r1-v1:0 only after checking the console.
R1 invocation fails	Cross-Region inference profile may be needed	Try the documented geo inference ID where applicable, such as us.deepseek.r1-v1:0.
Chat Completions fails	Model does not support Chat Completions	Use V3.2 or V3.1, not R1, for Chat Completions.
High cost	Long prompts or verbose outputs	Reduce context, cap maxTokens, cache common responses, and monitor usage.
High latency	Large context or complex reasoning	Use smaller prompts, streaming, or a faster model for low-latency tasks.
Guardrails block expected content	Configuration too strict	Review blocked categories, denied topics, and thresholds.
Tool calling mismatch	Server-side tool calling not supported	Use client-side orchestration where supported and validate outputs.
Marketplace cost surprise	Endpoint or infrastructure billing	Review Marketplace subscription and endpoint configuration.

DeepSeek in Amazon Bedrock vs Other AWS AI Model Options

DeepSeek is one model family among many available through Amazon Bedrock. AWS’s model catalog includes models from multiple providers, including Amazon, Anthropic, Meta, Qwen, and others.

Option	When it may fit better than DeepSeek
Amazon Nova	When you want Amazon-native models and tight AWS ecosystem alignment.
Anthropic Claude	When your application prioritizes long-form writing, instruction following, or existing Claude-specific workflows.
Meta Llama	When you want open-weight model options and broad ecosystem support.
Qwen or other open-weight models	When coding, multilingual, or open model deployment trade-offs fit your use case.
DeepSeek	When reasoning, coding, math, and technical analysis are central and the available APIs, regions, and pricing fit your requirements.

Do not assume DeepSeek is always better. Model choice depends on reasoning quality, latency, cost, context window, tool support, language support, security requirements, and deployment path.

Best Practices Before Production Deployment

Checklist item	Status
Verify model name, model ID, endpoint, and AWS Region.	☐
Confirm API support: Invoke, Converse, streaming, or Chat Completions.	☐
Use least-privilege IAM policies.	☐
Avoid root credentials and long-term static credentials.	☐
Add Guardrails for harmful content, sensitive data, and denied topics.	☐
Run model evaluation against your real prompts and datasets.	☐
Red-team prompt injection and sensitive workflows.	☐
Log usage, latency, errors, and token counts.	☐
Set budget alerts and cost dashboards.	☐
Validate outputs for hallucination, bias, and unsafe recommendations.	☐
Document fallback models and failure behavior.	☐
Re-check pricing, model IDs, and region availability before launch.	☐

Amazon Bedrock evaluations can assess models, knowledge bases, and RAG sources, including metrics such as robustness and correctness for retrieval and generation workflows.

Suggested Internal Links

• Link to your AWS generative AI consulting page using anchor text: AWS generative AI consulting
• Link to your RAG implementation guide using anchor text: RAG application architecture
• Link to your cloud security page using anchor text: AWS AI security best practices
• Link to your model evaluation guide using anchor text: LLM evaluation framework

FAQ About DeepSeek in Amazon Bedrock

Conclusion

DeepSeek in Amazon Bedrock is a strong option for teams that want DeepSeek’s reasoning and coding capabilities inside AWS’s enterprise governance model. The best choice depends on the model version, endpoint, API, region, price, context window, Guardrails requirements, and production-readiness standards.

For most developers, start with DeepSeek V3.2 if you need the newest documented DeepSeek model, long context, Converse, and Chat Completions compatibility. Use DeepSeek-V3.1 when its hybrid thinking/direct-answer behavior fits your workload. Use DeepSeek-R1 when your priority is reasoning and you do not need Chat Completions.

Before deploying, verify model IDs, pricing, region availability, and API support in the Amazon Bedrock console and official AWS documentation.