Available tools Integration guide Tool details Workflows End-to-end example Error handling

About the AWS Marketplace MCP server

AWS Marketplace Model Context Protocol (MCP) provides AI-powered tools for AWS Marketplace discovery, evaluation, research, and proposal generation. MCP is a standardized protocol that enables AI assistants to interact with external systems through the following:

Tools: Functions that AI models can invoke to perform actions.
Resources: Data and context that can be shared with AI models.

All tools are stateless — each call is independent with no server-side conversation state.

Example use cases

The following are common ways to use the AWS Marketplace MCP server:

Find products that address business needs using natural language queries.
Evaluate multiple vendors quickly with AI-generated comparison reports.
Create comprehensive purchase proposals tailored to business requirements.
Get side-by-side analysis of competing solutions.

Endpoint: https://marketplace-mcp.us-east-1.api.aws/mcp

Protocol: MCP over Streamable HTTP (JSON-RPC 2.0). All responses are single JSON payloads.

Authentication: None required.

Available tools

All 6 tools are stateless and require no conversation context. All tool definitions, including full input/output schemas, are available programmatically through the standard MCP tools/list endpoint. The schemas returned by tools/list are the canonical, always-current source of truth for parameter names, types, and constraints.

The following table summarizes each tool and whether it is read-only.

Tool name	Description	Read-only
get_aws_marketplace_report_guidelines	Returns workflow instructions and report format templates for recommendations, comparisons, or evaluations. Call first for any report workflow.	Yes
search_aws_marketplace_solutions	Searches the AWS Marketplace catalog by queries. Supports batch queries (up to 10) and cursor-based pagination.	Yes
get_aws_marketplace_solution	Gets detailed solution metadata by solution IDs (reviews, pricing, sentiments, rankings, CTAs).	Yes
get_aws_marketplace_related_solutions	Gets related solutions for given solution IDs, ranked by relation score.	Yes
research_aws_marketplace_solution	Performs deep web research on solutions (features, reviews, limitations, competitors, pricing, integrations, case studies). Hidden from clients with native web search.	Yes
submit_aws_marketplace_feedback	Submits user feedback (positive/negative) about report quality.	No

Integration guide

You can integrate with the AWS Marketplace MCP server in two ways: through a no-code Claude Connector or through a programmatic MCP client.

Claude Connector (recommended)

The fastest way to use AWS Marketplace MCP tools is through the AWS Marketplace connector for Claude. This requires no coding or MCP client setup — Claude handles tool discovery and invocation automatically.

Setup:

Open the AWS Marketplace connector in the Claude Connectors Directory.
Choose Connect to enable it.
In any Claude conversation, choose the + button (lower left) or type / to open the menu.
Hover over Connectors and toggle on AWS Marketplace.
Ask Claude to find, compare, or evaluate AWS Marketplace products — it automatically uses the MCP tools.

For more details on how connectors work, see Use connectors to extend Claude's capabilities.

Example prompts:

"Find the best SIEM solutions on AWS Marketplace for a mid-size company"
"Compare Datadog vs New Relic on AWS Marketplace"
"Build an evaluation report for Terraform Cloud on AWS Marketplace"

MCP client integration

For programmatic integrations or custom agent frameworks, connect directly to the MCP endpoint.

Prerequisites

You need the following to get started:

An MCP-compatible agent framework or client.
An HTTP client capable of making JSON-RPC 2.0 requests.

Step 1: Set up MCP client

Use a standard MCP client that supports HTTP transport.

Endpoint:


https://marketplace-mcp.us-east-1.api.aws/mcp

The following methods are supported:

POST with method: "initialize" — Initialize session and obtain Mcp-Session-Id.
POST with method: "tools/list" — Discover available tools and their schemas.
POST with method: "tools/call" — Invoke a tool.

Session identifier: This server uses MCP sessions, as defined by the Streamable HTTP transport in the MCP specification, version 2025-06-18. The response to initialize includes an Mcp-Session-Id header, and MCP clients send it on every later request. If you build requests yourself, you must send it too. Requests without the header fail with HTTP 400. Requests fail with HTTP 404 if the identifier was not issued by the server, or if it has expired. If you receive a 404, call initialize again.


Mcp-Session-Id: <stable-id>

Authentication: No authentication is required. Omit auth headers in HTTP requests.

Step 2: Obtain and register tools (tool discovery)

All tool definitions are available programmatically through the standard MCP tools/list method. This is the recommended way to obtain current input/output schemas, as tool schemas may be updated independently of this documentation. Call tools/list once during initialization and register the returned tools in your agent's tool manifest or system prompt.

The following example shows a tools/list request.

Request:


{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

Response (abbreviated):


{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "get_aws_marketplace_report_guidelines",
        "description": "...",
        "inputSchema": { ... }
      },
      {
        "name": "search_aws_marketplace_solutions",
        "description": "...",
        "inputSchema": { ... }
      },
      {
        "name": "get_aws_marketplace_solution",
        "description": "...",
        "inputSchema": { ... }
      },
      {
        "name": "get_aws_marketplace_related_solutions",
        "description": "...",
        "inputSchema": { ... }
      },
      {
        "name": "research_aws_marketplace_solution",
        "description": "...",
        "inputSchema": { ... }
      },
      {
        "name": "submit_aws_marketplace_feedback",
        "description": "...",
        "inputSchema": { ... }
      }
    ]
  }
}

Each tool entry includes the tool name, a detailed description with usage guidance and examples, and a complete inputSchema with parameter types, constraints, and validation rules.

HTTP transport

AWS Marketplace MCP uses HTTP transport, where the server operates as an independent HTTP service that can handle multiple client connections.

The following are key transport characteristics:

HTTP POST for requests: Every client message is sent as a new HTTP POST request.
JSON responses: All tools return JSON responses (Content-Type: application/json).
Session management: The server issues an identifier in the response to initialize. Send it in the Mcp-Session-Id header on every later request.
Protocol version: The server supports MCP specification version 2025-06-18.

Required HTTP headers:


Content-Type: application/json
Accept: application/json, text/event-stream
Mcp-Session-Id: <stable-id>
MCP-Protocol-Version: 2025-06-18

The following example shows a tool call request and response.

Example request:


POST /mcp HTTP/1.1
Content-Type: application/json
Accept: application/json, text/event-stream
Mcp-Session-Id: 00000000-0000-0000-0000-000000000000
MCP-Protocol-Version: 2025-06-18

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "search_aws_marketplace_solutions",
    "arguments": {
      "queries": ["SIEM solutions"]
    }
  }
}

Example response:


{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\"results\":[...],\"next_cursor\":null}"
      }
    ],
    "structuredContent": {
      "results": [...],
      "next_cursor": null
    }
  }
}

Tool details

This section describes each tool's input parameters, output format, and usage guidance.

get_aws_marketplace_report_guidelines

Returns workflow instructions and output format template for a given report type. Call this first for any recommendation, comparison, or evaluation workflow.

This tool returns different prompts depending on client capabilities — clients with native web search get prompts with embedded search queries instead of research_aws_marketplace_solution tool references.

Input:


{
  "workflow_type": "recommendations" | "comparison" | "evaluation"
}

The following table describes the input parameters.

Field	Type	Required	Description
`workflow_type`	enum	Yes	`"recommendations"` for ranked product discovery, `"comparison"` for side-by-side analysis, `"evaluation"` for single-product assessment.

Output:


{
  "workflow_type": "recommendations",
  "guidelines": "# AWS Marketplace Recommendations Workflow\n\n..."
}

The following table describes the output fields.

Field	Type	Description
`workflow_type`	string	The requested workflow type.
`guidelines`	string	Combined workflow instructions and markdown format template.

When to use each workflow:

recommendations — "find monitoring tools", "I need a CI/CD solution", "SOC2-compliant security scanning under $5k/month".
comparison — "compare Datadog vs New Relic", "Splunk vs Elastic for log management".
evaluation — "build evaluation report for Terraform Cloud", "justify purchasing New Relic to my CTO".

search_aws_marketplace_solutions

Searches AWS Marketplace and returns a list of relevant solutions based on the user's queries. Supports batch queries (up to 10) and cursor-based pagination for single queries.

Input:


{
  "queries": ["Drata compliance", "Vanta compliance"],
  "max_results": 5,
  "cursor": null
}

The following table describes the input parameters.

Field	Type	Required	Description
`queries`	string[]	Yes	Array of search queries (1-10). Also accepts legacy `query` (single string, auto-converted to array).
`max_results`	number	No	Maximum results per query (1-100, default: 10).
`cursor`	string	No	Pagination cursor (only works for single query, ignored for batch).

Output:


{
  "results": [
    {
      "solution_id": "prodview-abc123",
      "solution_name": "Drata",
      "vendor_name": "Drata Inc",
      "vendor_url": "https://aws.amazon.com/marketplace/seller-profile?id=...",
      "solution_description": "Continuous compliance automation...",
      "solution_url": "https://aws.amazon.com/marketplace/pp/prodview-abc123",
      "reviews_summary": {
        "reviews_count": 150,
        "average_rating": 4.7
      }
    }
  ],
  "next_cursor": "eyJvZmZzZXQiOjEwLCJwYWdlU2l6ZSI6MTB9"
}

The following table describes the output fields.

Field	Type	Description
`results`	MinimalSolutionMetadata[]	Array of matching solutions.
`next_cursor`	string \| null	Pagination cursor for next page (single query only). `null` when no more results.

Batch behavior: For multiple queries, results are combined and deduplicated by solution_id. The pagination cursor is not returned for batch requests.

Pagination: If next_cursor is returned (single-query requests only), pass it back as the cursor parameter to retrieve additional results. When next_cursor is null, all matching solutions have been retrieved.

get_aws_marketplace_solution

Retrieves comprehensive solution metadata by solution ID, including reviews, pricing options, and call-to-action links. Supports batch requests (up to 10 IDs).

Input:


{
  "solution_ids": ["prodview-abc123", "prodview-xyz789"]
}

The following table describes the input parameters.

Field	Type	Required	Description
`solution_ids`	string[]	Yes	Array of solution IDs (1-10). IDs start with `prodview-`. Also accepts legacy `solution_id` (single string, auto-converted).

Output:


{
  "solutions": [
    {
      "solution_id": "prodview-abc123",
      "solution_name": "Datadog",
      "solution_description": "Comprehensive monitoring and analytics...",
      "solution_url": "https://aws.amazon.com/marketplace/pp/prodview-abc123?ref_=...",
      "vendor_name": "Datadog, Inc.",
      "vendor_url": "https://aws.amazon.com/marketplace/seller-profile?id=...&ref_=...",
      "highlights": ["Real-time monitoring", "700+ integrations"],
      "reviews_summary": {
        "reviews_count": 245,
        "average_rating": 4.6
      },
      "review_sentiments": [
        {
          "sentiment_category": "functionality",
          "overall_polarity": "positive",
          "positive_score": "85%",
          "negative_score": "5%",
          "mixed_score": "10%",
          "sample_reviews": [
            {
              "review_text": "Excellent monitoring capabilities...",
              "rating": 5,
              "source_name": "G2"
            }
          ]
        }
      ],
      "free_trial_available": true,
      "pricing_options": [
        {
          "name": "Infrastructure Monitoring",
          "description": "$15 per host per month"
        }
      ],
      "fulfillment_options_types": ["SaaS"],
      "categories": ["Monitoring & Observability"],
      "security_certificates": ["SOC 2 Type II", "ISO 27001"],
      "rankings": [{ "category": "Monitoring", "rank": 3 }],
      "has_standard_contract": true,
      "call_to_action": {
        "procurement_url": "https://...",
        "request_for_demo_url": "https://...",
        "request_for_private_offer_url": "https://...",
        "procure_free_trial_url": "https://..."
      }
    }
  ]
}

The following table describes the output fields.

Field	Type	Description
`solutions`	SolutionOutput[]	Array of solution details (always array, even for single ID).

The following table describes the fields in each SolutionOutput object.

Field	Type	Description
`solution_id`	string	AWS Marketplace solution ID.
`solution_name`	string	Product name.
`solution_description`	string	Long or short description.
`solution_url`	string	Marketplace URL with ref tags.
`vendor_name`	string	Vendor display name.
`vendor_url`	string	Vendor profile URL with ref tags.
`highlights`	string[]	Product highlights.
`reviews_summary`	object	`{ reviews_count, average_rating }`
`review_sentiments`	ReviewSentiment[]	Sentiment by category (functionality, ease_of_use, customer_service, cost_effectiveness) with polarity scores and sample reviews.
`free_trial_available`	boolean?	Whether a free trial is available.
`pricing_options`	PricingOption[]	`{ name, description }` pairs.
`fulfillment_options_types`	string[]?	Fulfillment types such as SaaS, Container, or AMI.
`categories`	string[]?	Categories such as "Monitoring & Observability".
`security_certificates`	string[]?	Certifications such as "SOC 2 Type II" or "ISO 27001".
`rankings`	Ranking[]?	`{ category, rank }` — rank within category (1-100).
`has_standard_contract`	boolean?	Whether the product supports AWS Standard Contract.
`call_to_action`	CallToAction	`{ procurement_url, request_for_demo_url, request_for_private_offer_url, procure_free_trial_url }`

Returns related solutions for given solution IDs as identified by AWS Marketplace, sorted by relation score (descending). Supports batch requests (up to 10 IDs).

Input:


{
  "solution_ids": ["prodview-abc123"]
}

The following table describes the input parameters.

Field	Type	Required	Description
`solution_ids`	string[]	Yes	Array of solution IDs (1-10). Also accepts legacy `solution_id` (single string, auto-converted).

Output:


{
  "results": [
    {
      "solution_id": "prodview-abc123",
      "related_solutions": [
        {
          "solution_id": "prodview-xyz789",
          "solution_name": "New Relic",
          "vendor_name": "New Relic, Inc.",
          "vendor_url": "https://aws.amazon.com/marketplace/seller-profile?id=...",
          "solution_description": "Full-stack observability platform...",
          "solution_url": "https://aws.amazon.com/marketplace/pp/prodview-xyz789"
        }
      ]
    }
  ]
}

The following table describes the output fields.

Field	Type	Description
`results`	SingleRelatedSolutionsResult[]	One entry per input solution ID.
`results[].solution_id`	string	The input solution ID.
`results[].related_solutions`	MinimalSolutionMetadata[]	Related solutions sorted by relation score (descending).

If a solution ID has no related solutions, its related_solutions array is empty. Related solutions that are no longer listed are omitted.

research_aws_marketplace_solution

Performs deep web research on AWS Marketplace solutions. Runs web searches for each requested section and returns content with inline citation links. Supports batch requests (up to 5 IDs).

Visibility: This tool is hidden from clients with native web search capability (for example, Anthropic/ClaudeAI). Those clients get workflow prompts with embedded search queries instead.

Input:


{
  "solution_ids": ["prodview-abc123", "prodview-xyz789"],
  "sections": ["features", "integrations"]
}

The following table describes the input parameters.

Field	Type	Required	Description
`solution_ids`	string[]	Yes	Array of solution IDs in `prodview-*` format (1-5).
`sections`	ResearchSection[]	No	Sections to research. Default: all 7 sections.

The following table describes each available research section.

Section	What it returns
`features`	Official documentation, capabilities, specifications
`reviews`	G2 and PeerSpot customer reviews
`limitations`	Known issues, drawbacks, criticisms
`competitors`	Competitive positioning, alternatives
`pricing`	Cost information, pricing models, tiers
`integrations`	AWS ecosystem, APIs, third-party tools
`case_studies`	Customer success stories, testimonials, ROI

Output:


{
  "results": [
    {
      "solution_id": "prodview-abc123",
      "solution_name": "Datadog",
      "research": {
        "features": {
          "content": "Datadog provides 700+ integrations...",
          "citations": [
            {
              "index": "1",
              "title": "Datadog Integrations",
              "url": "https://docs.datadoghq.com/integrations/"
            }
          ]
        }
      }
    }
  ]
}

The following table describes the output fields.

Field	Type	Description
`results`	SingleResearchResult[]	One entry per input solution ID.
`results[].solution_id`	string	The researched solution ID.
`results[].solution_name`	string	Product name resolved from solution ID.
`results[].research`	object	Object with keys for each requested section.
`results[].research[section].content`	string	Research content with inline citation links.
`results[].research[section].citations`	Citation[]	`{ index, title, url }` for each citation.

Concurrency: Solutions are researched in parallel. Sections within each solution are sequential to avoid overwhelming downstream services.

submit_aws_marketplace_feedback

Submits user feedback about an AWS Marketplace report. Call this tool after completing any recommendation, comparison, or evaluation workflow.

Input:


{
  "sentiment": "negative",
  "categories": ["Incomplete", "Other"],
  "feedback_text": "Missing pricing details"
}

The following table describes the input parameters.

Field	Type	Required	Description
`sentiment`	enum	Yes	`"positive"` or `"negative"`.
`categories`	string[]	No	For negative feedback: `"Irrelevant"`, `"Incomplete"`, `"Inaccurate"`, `"Other"`.
`feedback_text`	string	No	Free-form text (max 1000 characters).

Output:


{
  "success": true,
  "message": "Thank you for your feedback. We'll use it to improve."
}

Workflows

The AWS Marketplace MCP server supports three primary workflows for product research and direct catalog lookups.

Report generation (recommendations, comparisons, evaluations)

This is the primary workflow for AI-assisted product research. It uses get_aws_marketplace_report_guidelines as the orchestration entry point.

Flow:

Call get_aws_marketplace_report_guidelines with the appropriate workflow_type.
The tool returns step-by-step workflow instructions and an output format template.
The AI assistant follows the returned instructions, which typically involve calling the search, solution-detail, and research tools to gather data.
The assistant generates a formatted report following the output template.
After delivering the report, the assistant collects user feedback through submit_aws_marketplace_feedback.

Recommendations workflow:

get_aws_marketplace_report_guidelines({ workflow_type: "recommendations" })
search_aws_marketplace_solutions({ queries: ["Product A", "Product B"], max_results: 3 })
Write report following the format template.
submit_aws_marketplace_feedback({ sentiment: "positive" })

Comparison workflow:

get_aws_marketplace_report_guidelines({ workflow_type: "comparison" })
get_aws_marketplace_solution({ solution_ids: ["prodview-abc", "prodview-xyz"] })
research_aws_marketplace_solution({ solution_ids: [...], sections: ["features", "integrations"] })
Build comparison matrix and write report following the format template.
submit_aws_marketplace_feedback({ sentiment: "positive" })

Evaluation workflow:

get_aws_marketplace_report_guidelines({ workflow_type: "evaluation" })
get_aws_marketplace_solution({ solution_ids: ["prodview-target"] })
research_aws_marketplace_solution({ solution_ids: ["prodview-target"], sections: ["features", "reviews", "limitations", "case_studies"] })
Write evaluation report following the format template.
submit_aws_marketplace_feedback({ sentiment: "positive" })

Direct catalog lookup

For programmatic integrations or quick lookups that don't require AI analysis, you can call the search, solution-detail, and related-solutions tools directly without get_aws_marketplace_report_guidelines.

Search then detail lookup:

Call search_aws_marketplace_solutions with one or more keyword queries.
Use the returned solution_id values to call get_aws_marketplace_solution for full details.
Optionally call get_aws_marketplace_related_solutions to discover related products.

Feedback collection

After completing any workflow, the assistant should collect user feedback.

Ask the user if the response was helpful.
If positive, call submit_aws_marketplace_feedback with sentiment: "positive".
If negative, ask which categories apply (Irrelevant, Incomplete, Inaccurate, Other), optionally collect free-text feedback, and submit.

End-to-end example

The following example demonstrates a complete recommendations workflow from initial query to feedback submission.

Step 1 — Get workflow instructions:


{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_aws_marketplace_report_guidelines",
    "arguments": {
      "workflow_type": "recommendations"
    }
  }
}

Step 2 — Search for candidate solutions:


{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "search_aws_marketplace_solutions",
    "arguments": {
      "queries": ["SIEM security monitoring", "log management SIEM"],
      "max_results": 10
    }
  }
}

Step 3 — Retrieve detailed metadata for top candidates:


{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "get_aws_marketplace_solution",
    "arguments": {
      "solution_ids": ["prodview-abc123", "prodview-def456", "prodview-ghi789"]
    }
  }
}

Step 4 — Submit user feedback:


{
  "jsonrpc": "2.0",
  "id": 4,
  "method": "tools/call",
  "params": {
    "name": "submit_aws_marketplace_feedback",
    "arguments": {
      "sentiment": "positive",
      "feedback_text": "Recommendations were relevant and well-structured"
    }
  }
}

Error handling

Errors fall into three categories: protocol errors, input validation errors, and tool execution errors.

Protocol errors

Protocol errors are returned as a JSON-RPC error object when the request can't be processed as an MCP request. They have two kinds of cause: the Mcp-Session-Id header, and an unsupported method.

Session errors are returned before any tool runs. Common causes:

The Mcp-Session-Id header is missing: HTTP 400.
The identifier is malformed (not a UUID v4 or JWT): HTTP 400.
The server did not issue the identifier: HTTP 404.
The identifier has expired: HTTP 404.

A missing Mcp-Session-Id returns HTTP 400:


{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Bad Request: mcp-session-id header is required"
  },
  "id": null
}

An unknown or expired identifier returns HTTP 404:


{
  "jsonrpc": "2.0",
  "error": {
    "code": -99999,
    "message": "Bad Request: Invalid or expired session ID"
  },
  "id": null
}

To resolve a session error, call initialize again and retry the request with the new Mcp-Session-Id.

Unsupported methods return HTTP 200 with a JSON-RPC error object. The following example shows an unknown method.


{
  "jsonrpc": "2.0",
  "id": 10,
  "error": {
    "code": -32601,
    "message": "Method not found"
  }
}

Input validation errors

Input validation errors are returned when the arguments of a tool call fail schema validation (for example, a missing required field, an invalid value, or exceeding a maximum array length). An unknown tool name is returned the same way. These are tool errors, not protocol errors: the response has isError: true and the text starts with MCP error -32602: Input validation error, followed by one entry for each failing field. Each entry includes the path of the field, and for enum values, the allowed options.

The following example shows a call to search_aws_marketplace_solutions without the required queries field.


{
  "jsonrpc": "2.0",
  "id": 11,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "MCP error -32602: Input validation error: Invalid arguments for tool search_aws_marketplace_solutions: [ { \"code\": \"invalid_type\", \"expected\": \"array\", \"received\": \"undefined\", \"path\": [\"queries\"], \"message\": \"Required\" } ]"
      }
    ],
    "isError": true
  }
}

Tool execution errors

Tool execution errors are returned when a tool invocation fails at runtime (for example, rate limiting, invalid solution IDs, or upstream service errors). Tool errors are reported within the result object, not as MCP protocol-level errors, so the AI assistant can see and handle the error.

The following example shows a call to get_aws_marketplace_solution with a solution ID that doesn't exist.


{
  "jsonrpc": "2.0",
  "id": 12,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\"error\":{\"type\":\"ValidationException\",\"message\":\"Solution not found: prodview-doesnotexist\",\"code\":\"INVALID_FIELD_VALUE\"}}"
      }
    ],
    "structuredContent": {
      "error": {
        "type": "ValidationException",
        "message": "Solution not found: prodview-doesnotexist",
        "code": "INVALID_FIELD_VALUE"
      }
    },
    "isError": true
  }
}

Warning Javascript is disabled or is unavailable in your browser.

To use the Amazon Web Services Documentation, Javascript must be enabled. Please refer to your browser's Help pages for instructions.

Document Conventions

Notifications for the Catalog API

Using the API as a seller