AWS Builder Center
Identical or Similar? AI-Powered Product Matching with Amazon Bedrock and S3 Vectors

Identical or Similar? AI-Powered Product Matching with Amazon Bedrock and S3 Vectors

How can AI tell duplicate products from similar ones when their names are written differently? Using video games from the Amazon Reviews 2023 dataset, I build a serverless pipeline on AWS: Amazon Bedrock extracts product attributes, S3 Vectors finds similar candidates, and deterministic rules decide most pairs, reserving AI for ambiguous cases. Orchestrated with Step Functions and Lambda, it processed 3,740 products in 14 minutes, with 97.7% of the decisions made by rules.

1. Introduction

A few weeks ago, someone asked me a question:
"How can I use AI to improve my inventory if I have similar or duplicate products, but their names aren't written exactly the same way?"
To explore how to solve this problem, we'll use video games as an example.
⚠️ First spoiler: that's the type of data we'll be working with in this article.

preview

  • Call of Duty: Black Ops and Call of Duty: Black Ops 2 have almost identical titles, but they are different games. They are not duplicates.
  • Black Ops 2 and Black Ops II are exactly the same game, even though a computer sees them as two different text strings.
  • FIFA 14 for PlayStation 3 and FIFA 14 for Xbox 360 have the same title, but the platform is different, so they may represent distinct commercial products.

So, what does it really mean for two products to be duplicates? Two records may describe the same product even if their names are different; nearly identical names may refer to different products; and the same product may be sold in different formats, which we may need to keep separate depending on the business rules.

This is not a minor issue: when products are not identified consistently, stock gets spread across several records, prices are harder to compare, searches return repeated listings, and reviews are split. Some differences may seem obvious to a person, but with thousands of records, we can't rely on someone detecting them manually.
⚠️ Second spoiler: AI isn't going to solve everything.
We could send every product to an AI model and ask whether it's a duplicate. But processing an entire catalog this way can be expensive, and we can't guarantee that the responses will always be consistent.

In other projects, I have worked with text normalization, regular expressions, and similarity techniques, and in many cases they are sufficient. For this MVP, I wanted to explore a different approach: using rules to handle straightforward cases, while reserving AI for ambiguous scenarios that cannot be resolved by a rule.

Before building the solution, there are three questions I want to answer:
  1. How can we distinguish truly duplicate products from those that are simply similar?
  1. When does AI add value, and when is it better to use traditional rules?
  1. Can we build an MVP on AWS using a serverless architecture while keeping costs under control?




2. 🗂️ How Do We Manage Product Information?

When a company sells products through multiple channels, keeping information consistent becomes a challenge. Product Information Management (PIM) systems allow companies to centralize, enrich, and distribute product information (names, descriptions, specifications, images) from a single location.  Adobe explains here  how these systems work.

game pim

 Source: Author's own diagram. 

Depending on the organization, product information may live in a spreadsheet, a database table, a CRM, SAP MM, or a PIM. The idea is to explore a solution accessible through an API that helps detect potential duplicates, regardless of where the information is managed.




3. MVP Design Principles

These are the principles that defined the scope and design of the MVP:
1. A public, realistic dataset.
The product metadata from  Amazon Reviews 2023 , Video Games category. The same game can be sold for different platforms, in different editions, in physical or digital format, or refurbished.
2. A limited scope based on an external criterion.
A subset based on the 20 best-selling video game franchises according to Wikipedia, selected with regular expressions on the titles. This keeps the volume manageable and the criterion reproducible.
3. Cost as a design variable.
A serverless AWS architecture, with on-demand processing and low-cost AI models.
4. Rules first, AI where it adds value.
Deterministic rules for simple cases; the language model only for interpreting text, abbreviations, or ambiguous matches.
5. Explicit business criteria.
Whether two products are the same, a variant, or different depends on the business. Here, the criteria live in the prompts and pipeline rules; in production, they must be validated with the business teams.
6. A pipeline to evaluate, not a finished system.
The goal is to check whether the approach is viable and measure its behavior: time, cost, share of decisions resolved with rules, and extraction quality across prompt versions.



4. Architecture

The goal of the architecture is to transform a disorganized product catalog into one where each listing is associated with the actual product it represents, available for real-time queries. It combines batch processing of the entire catalog with a real-time component for new products and search queries.


architecture

 Source: Architecture diagram created by the author. 

The architecture is organized into three parts:
  • Input: the Amazon Reviews 2023 dataset, filtered with the MVP selection criteria and the data quality rules identified during the EDA.
  • Pipeline: extracts product attributes with a language model, converts them into vectors, searches for similar products, decides whether they are duplicates, variants, or different products, and stores a product and family identifier in DynamoDB.
  • Inference: receives a natural language query, such as  FIFA 14 PS3 digital code , or a new product, and determines whether it matches an existing product, is a variant, or is new.

The services, grouped according to the diagram's legend:
🟩 Storage
  • Amazon S3: stores each stage's data in its own folder, so any step can be traced and reprocessed.
  • Amazon S3 Vectors: stores product vectors and runs similarity searches without managing a vector database.
  • Amazon DynamoDB: stores each product with its identifiers for millisecond key-based queries.
🟨 Compute / AI
  • Amazon Bedrock, with three models:
  • Nova Micro: extracts the attributes of each product; the most cost-effective option.
  • Titan Text Embeddings V2: converts each product into a vector.
  • Nova Lite: resolves ambiguous pairs, with stronger reasoning than Nova Micro.
🟪 Pipeline
  • AWS Lambda: runs each processing step as an independent function.
  • AWS Step Functions: orchestrates the steps and retries temporary failures.
🟥 Security
  • AWS IAM: one least-privilege role per Lambda function.
  • AWS KMS: encrypts data at rest.
🟦 Logs
  • Amazon CloudWatch: centralizes logs and metrics such as duration and memory usage.



5. Use Case Development

5.1. 🔍 What Is EDA?

Exploratory Data Analysis (EDA) helps us understand a dataset before applying models or making decisions: identify patterns, detect anomalies, and assess data quality. Statistician John W. Tukey formalized it in his book Exploratory Data Analysis (1977).
🤖 And what about generative AI projects?
It can be tempting to send raw data to a model and hope for the best. But every unnecessary field adds tokens that we pay for with each call, and every inconsistent data point is a potential error the model can propagate. EDA helps decide which data to send and what to fix beforehand with simple rules. I performed ten checks:
eda

 Source: Author's own infographic. 

The findings with the greatest impact on the design were:
  •  main_category  does not describe the product: it refers to the store department. The platform is taken from  categories .
  • There are hidden nulls: thousands of products have an empty categories list.
  • Not everything in Games is actually a game: there are controllers, statues, and bundles.
  • Accessory titles are full of keywords: so comparing titles directly does not work.
  • Some fields seem useful, but are not:  Pricing  is a legal notice, and  Date First Available  is not the release date.
📓 Would you like to explore the full analysis? The  eda_video_games.ipynb  notebook is available in the project repository.



5.2. ☁️ Infrastructure Deployment

To keep this MVP simple, I created the resources through the AWS Console and included the scripts and AWS CLI commands in the repository to reproduce the deployment.

Prerequisites: an AWS account with access to Amazon Bedrock in us-east-1 (Nova Micro, Nova Lite, and Titan Text Embeddings V2), AWS CLI v2, and the  meta_Video_Games.jsonl  file from the Amazon Reviews 2023 dataset.


Clone the repository and navigate to the project directory:
git clone https://github.com/RominaElenaMendezEscobar/aws-games-products.git
cd aws-games-products

The resources are organized by service under  aws/ . Each Lambda function has its own directory with its code and permissions policy ( policy-role.json ):
aws/
├── S3/ → data bucket
├── S3Vectors/ → vector bucket and index
├── DynamoDB/ → products table
├── lambda/ → 8 functions + deployment script
└── step-function/ → pipeline definition and its role

The deployment follows this order: storage → Lambda functions → Step Functions. Before deploying, replace  <account_number>  in each  policy-role.json  with your AWS account ID.
📄 The step-by-step commands are in the repository README.




5.3. 🛠️ Data Preparation

A Lambda function applies the rules defined during the EDA before any AI model is involved:
  • Discard products without titles or categories, since they cannot be identified.
  • Remove columns without useful information, to avoid carrying empty fields into later stages.
  • Convert prices to numeric values.
  • Keep only the  Games  category.
Then, I selected the 20 best-selling franchises. This choice was intentional: FIFA has annual releases that should not be confused with one another, while Mario and Zelda have games for different Nintendo consoles. Similar titles do not necessarily identify the same product.

The dataset is progressively reduced at each stage:
  1. 📦 Original dataset: 137,269 products
  1. 🧹 Products with titles and categories: 124,624
  1. 🎮 Products in the Games category: 46,530
  1. 🏆 Products from the 20 best-selling franchises: 3,740

Each stage stores its results in a separate S3 folder ( raw/ ,  clean/ ,  mvp/ …), and pipeline outputs go into a run-specific subfolder, such as  attributes/top20-v8/ . This made it possible to rerun later stages when refining the prompt, without repeating the cleaning, and to compare versions.



5.4. 🧠 Prompt Design and Evaluation

The goal is not to ask a model to find duplicates across the entire catalog, but to break the problem into specific tasks.

prompt

 Source: Author's own infographic. 

The main requirements were:
  • Normalize products: extract base title, platform, edition, format, region, publisher, and product type.
  • Maintain structured output: valid JSON with the fields expected by the pipeline.
  • Apply business rules: distinguish an edition from a re-release, physical from digital, a game from an accessory.
  • Avoid unnecessary assumptions: do not invent attributes.
  • Control costs and execution time.




5.4.1. ✂️ Two Prompts for Two Different Tasks

I separated the process into two tasks, each with its own model: Nova Micro to normalize every product, and Nova Lite to resolve ambiguous pairs.
With the Bedrock Converse API, the prompt is sent as a system message and the product as a user message:
response = bedrock.converse(
modelId="us.amazon.nova-micro-v1:0",
system=[{"text": SYSTEM_PROMPT}],
messages=[{"role": "user",
"content": [{"text": json.dumps(build_payload(product))}]}],
inferenceConfig={"temperature": 0, "maxTokens": 300},
)
attributes = json.loads(response["output"]["message"]["content"][0]["text"])

 build_payload  sends only the fields selected during the EDA: title, store, categories, four keys from  details , and three product features.

SYSTEM_PROMPT: Product Normalization (Nova Micro)

It runs on every product. For example, the listing  "GTA : Vice City - platinum [Playstation 2]"  returns:
{
"product_type": "game",
"base_title": "Grand Theft Auto: Vice City",
"platform": "PlayStation 2",
"edition": "Standard",
"format": "physical",
"region": "unknown",
"publisher": "Rockstar Games",
"confidence": "high"
}
The Platinum label is treated as a budget re-release and normalized to Standard. The key is not just to clean up the title, but to represent equivalent products consistently without losing important distinctions, such as the platform.

DECISION_PROMPT: Candidate Pair Comparison (Nova Lite)

It is reserved for ambiguous pairs. For example:
A: Mario & Sonic at the Olympic Games [Nintendo Wii]
B: Mario and Sonic at the Olympic Winter Games - Nintendo Wii
They share many words, but they are different games: Winter is a meaningful distinction. The model returns  {"relation": "different", "reason": "The base titles of the games are different."} .
📍 Both prompts are also used by  game-catalog-resolve-product  for real-time queries.



5.4.2. 🏗️ How I Built the Extraction Prompt

The  SYSTEM_PROMPT  was organized into five parts:

prompt-structure

 Source: Author's own diagram. 

  • Role: a product data specialist who responds only in JSON.
  • Purpose: the output will be used to detect duplicates, so consistency matters more than preserving the original title.
  • Rules: each one comes from an EDA finding or an observed error: labels in brackets, “Renewed” is not an edition, budget re-releases are the same product, sequel numbers are part of the title.
  • Schema: the fields and their allowed values, including a list of platforms.
  • Examples: two cases from franchises outside the dataset, to check that the model generalizes instead of copying answers.



5.4.3. 🧪 Testing in Amazon Bedrock

I used the Amazon Bedrock Playground, which lets you change the prompt, model, and parameters and see the response immediately, without writing a single line of code. Its comparison mode shows two models side by side, with token consumption and latency.

bedrock

 Source: Screenshot captured by the author from the Amazon Bedrock console (AWS). 
The tests covered several dimensions:
  • 🤖 Model comparison: Nova Micro and Nova Lite with equivalent inputs. The model with stronger reasoning is used only where it adds value.
  • 📦 One product per call: grouping ten products per call would have cut calls from 3,740 to 374, but the model mixed information between records. I kept one call per product, with eight concurrent calls.
  • 🌍 Spanish queries: such as  pokemon esmeralda game boy advance  or  el mario kart de la wii , to check that they are normalized to the catalog's vocabulary.
  • 🧪 Regression testing: each version was tested against previously failing cases and control cases, such as “FIFA 23”, “Pokémon X”, or “Call of Duty: WWII”.
  • 🧠 Conversation context: the Playground preserves chat history, which influenced later responses. Each test had to start a new conversation, just like each Lambda invocation.
💡 Lessons Learned
  1. Examples work better than abstract rules. Four ways of instructing the model to convert Roman numerals failed in some cases; two examples fixed “Black Ops II”, “Final Fantasy VII”, and “GTA V” while preserving “Mega Man X”.
  1. Examples can also teach what you don't want. A single example with  "platform": "unknown"  left the platform unidentified for 14% of the games; fixing the examples brought it down to 1%.
  1. “Don't guess” is not always the best instruction.  unknown  acts as a wildcard in the comparison rules. For format, an explicit business assumption worked better: products without a digital label are physical.
  1. Test under the same conditions as production. The Playground and the pipeline gave different results because I sent only the title in the Playground.
  1. Measure every change. Every improvement has a token cost, and a new rule can break something that worked.



5.5. ⚙️ The Pipeline

The catalog is processed by an AWS Step Functions state machine that orchestrates six Lambda functions. Each one reads the previous stage's output from S3 and stores its results in a separate folder.

step-function

 Source: Screenshot captured by the author from the AWS Step Functions console (AWS). 

I chose Step Functions for orchestration and retries (for example, Bedrock throttling), traceability of each step's inputs, outputs, and errors, and cost: it runs on demand, without servers to manage ( pricing ).

Before the workflow begins,  game-catalog-etl  cleans the dataset ( raw/ ) and stores the products in scope in  mvp/ . Then:
  1. PrepareRequests ·  game-catalog-prepare-batch : generates one extraction request per product, with only the relevant fields. 📥  mvp/  → 📤  bedrock-input/ 
  1. ExtractAttributes ·  game-catalog-extract-ondemand-access : sends each request to Nova Micro, with eight concurrent calls. 📥  bedrock-input/  → 📤  bedrock-output/ 
  1. ParseResults ·  game-catalog-parse-results : validates the JSON, separates games from bundles, DLC, and accessories, and generates a quality report. 📥  bedrock-output/  → 📤  attributes/ ,  reports/ 
  1. CreateEmbeddings ·  game-catalog-embed : converts each game into a vector with Titan Text Embeddings V2 and stores it in S3 Vectors. 📥  attributes/  → 📤 S3 Vectors
  1. DecidePairs ·  game-catalog-decide-pairs : finds the nearest neighbors and decides each pair with rules or Nova Lite. 📥 S3 Vectors → 📤  pairs/ ,  reports/ 
  1. BuildClusters ·  game-catalog-build-clusters : assigns each product a  canonical_id  and a  family_id . 📥  pairs/ ,  attributes/  → 📤  clusters/ ,  reports/ , DynamoDB

Each execution receives an input with the bucket, a  run_name  (for example,  top20-v8 , which names the output folders), the franchise regular expressions, the models, the prompt version, and the S3 Vectors index. The full example is in the repository.

⏱️ Scalability: a single Lambda invocation cannot run for more than 15 minutes. To process the more than 46,000 products in the Games category, requests should be distributed in batches, for example with Step Functions Distributed Map, adjusting concurrency to Bedrock quotas.




5.6. ⚖️ How Do We Determine Whether Two Products Are the Same?

The central idea behind the design is to separate two questions:
  • 🔎 Which products are similar? Vector search answers this question.
  • ⚖️ Are they the same product? The attributes determine the answer.
If we relied on similarity alone, FIFA 14 for PS3 and FIFA 14 for Xbox 360 would be duplicates because their vectors are very close. However, they are different products, each with its own stock and price.




5.6.1. 🔎 Finding Candidates

Each game is converted into an identity text built from its normalized attributes, so that two listings written differently generate the same representation:
Grand Theft Auto: Vice City | PlayStation 2 | Standard | physical
def identity_text(attrs):
parts = [attrs["base_title"], attrs["platform"],
attrs["edition"], attrs["format"]]
return " | ".join(p for p in parts if p and p != "unknown")

Unknown attributes are omitted: including  "unknown"  would push apart two products that might be the same. Titan Text Embeddings V2 converts the text into a 1,024-dimensional vector, and S3 Vectors returns the 20 nearest neighbors; we keep those with a cosine distance below 0.25. This threshold reduces comparisons, but it does not decide on its own whether two products are duplicates.




5.6.2. 🌳 Determining the Relationship

Similar titles are not enough: we need to check whether they represent the same product, a variant, or different games.


game-pair-decision


 Source: Decision diagram created by the author. 

First, titles are normalized so that capitalization or punctuation do not matter (“Link’s Awakening” = “Links Awakening”). If the base titles match, we compare platform, edition, format, and region: if they are compatible, the pair is a duplicate; if a known attribute differs, it is a variant. Two attributes are compatible when they match or one is unknown, which helps with incomplete listings but may hide real differences.

If the titles differ but the vectors are very close (distance below 0.08), we are in a gray area, and Nova Lite decides. Otherwise, the products are different.

def rule_decision(a, b, distance):
"""Returns (relation, reason), or None when the pair goes to Nova Lite."""

if normalize_title(a["base_title"]) == normalize_title(b["base_title"]):
diffs = [
f for f in ["platform", "edition", "format", "region"]
if not compatible(a.get(f), b.get(f))
]

if not diffs:
return "duplicate", "same base_title and compatible attributes"

return "variant", "differs in " + ", ".join(diffs)

if distance < 0.08:
return None # gray zone: Nova Lite decides

return "different", "different base_title"
📄 The full code is in  aws/lambda/SP05-game-catalog-decide-pairs/lambda_function.py .
The thresholds (0.25 and 0.08) were set empirically. In production, a labeled reference set would be needed to validate them.





5.6.3. 🧩 Grouping Related Products

The classified pairs are turned into two levels of grouping:
  • 🏷️ canonical_id: listings that represent the same commercial product.
  • 👨👩👧 family_id: duplicates and their variants, such as the same game on different platforms, editions, or formats.




5.7. ⚡ Inference and Real-Time Queries

Once the pipeline finishes, we have a product database in DynamoDB and a vector index in S3 Vectors. With them, we can query the catalog in real time, and integrate it with a PIM or ERP:
  • 🛒 A purchasing team searches for “fifa 14 ps3 digital” and finds the correct listing.
  • 📦 A supplier submits a new product, and the system indicates whether it already exists or is a variant.
  • 🌍 Someone searches in Spanish within a catalog written in English.
The  game-catalog-resolve-product  Lambda function has two modes: search (free-text query) and product registration (a new product that is stored with its identifiers).

5.7.1. 🔍 How Search Works

The search does not compare the user's query with the product titles. It first converts the query into the same format used in the catalog.

1. Query and attributes. The query  fifa 14 ps3 codigo digital  is in Spanish and uses an abbreviation. Nova Micro, with the same extraction prompt, returns:
{
"product_type": "game",
"base_title": "FIFA 14",
"platform": "PlayStation 3",
"edition": "Standard",
"format": "digital",
"region": "unknown"
}
“ps3” became “PlayStation 3”, and “codigo digital” became format: digital: the query now uses the catalog's vocabulary.

2. Identity text and candidates. With  FIFA 14 | PlayStation 3 | Standard | digital , S3 Vectors returns “FIFA 14 - PS3 [Digital Code]” at distance zero, along with the physical versions.

3. Decision. DynamoDB provides the identifiers of each candidate, and the pipeline rules are applied: the digital listing is a duplicate, and the physical copies are variants.

4. Output.
{
"decision": "duplicate",
"canonical_id": "CAN-B00GGUW312",
"family_id": "FAM-B00CD90R7M",
"identity_text": "FIFA 14 | PlayStation 3 | Standard | digital",
"matched_with": {
"title": "FIFA 14 - PS3 [Digital Code]",
"distance": 0,
"method": "rule"
}
}

🧪 More Examples

The family_id allows us to retrieve all the variants of a game. For example, the Assassin’s Creed III family in DynamoDB has 8 listings grouped into 4 commercial products: Xbox 360, PlayStation 3, PC physical, and PC digital code.

example-1

 Source: Screenshot captured by the author from the AWS Lambda console (AWS). 

example-2

 Source: Screenshot captured by the author from the AWS Lambda console (AWS). 



6. Results

The pipeline processed 3,740 product listings in 14 minutes and 4 seconds, from preparing the requests to creating the product clusters.

6.1. ⏱️ Execution Time

  • ExtractAttributes: 8 min 26 s, mainly constrained by Bedrock's requests-per-minute quota.
  • CreateEmbeddings: 4 min 21 s.
  • DecidePairs: 55 s, to evaluate 10,449 candidate pairs.
  • The remaining stages took less than 15 seconds each.

6.2. ⚖️ Rules Before AI

10,209 of the 10,449 candidate pairs (97.7%) were classified with deterministic rules applied to the attributes extracted by the AI, and only 240 pairs (2.3%) required Nova Lite. These figures describe how the decisions were made, not their accuracy: measuring it would require a labeled reference dataset.

6.3. 💰 Attribute Extraction Cost

The ExtractAttributes step recorded 3,740 products processed with no errors, 5,661,802 input tokens, and 264,153 output tokens. With Amazon Nova Micro pricing in us-east-1:
  • Input: 5.66 million tokens × $0.035 per million = $0.20.
  • Output: 0.264 million tokens × $0.14 per million = $0.04.
  • Total: approximately $0.24.
This covers attribute extraction only; embeddings, Nova Lite, Lambda, Step Functions, and storage add to the total.

6.4. 📈 Prompt Evolution

The prompt went through eight versions. Between the first run on the 20 franchises (v6) and the final one (v8):
  • Games with no identified platform: from 5.3% to 1.1%.
  • Games with no identified format: from 8.3% to 3.1%.
  • Input tokens per product: from approximately 620 to 1,500.
  • Estimated extraction cost: from approximately $0.12 to $0.24.
Extraction improved, although this alone does not demonstrate greater accuracy in duplicate detection.



7. Conclusions

This MVP showed that deterministic rules, embeddings, and language models can be combined to detect potential duplicates without sending every comparison to an AI model.
It also showed that cost does not depend solely on the model. Data preparation, attribute selection, prompt design, and the rules for straightforward cases all have a direct impact on cost and execution time.

Before using a similar solution with a real-world catalog, I would focus on:
  • 📊 Measure accuracy with pairs labeled as duplicates, variants, or different products.
  • 🧩 Use more data, such as descriptions and images, evaluating their impact on quality and cost.
  • 🤖 Compare models by accuracy, latency, and cost.
  • 📈 Scale processing, reviewing Bedrock quotas and batch inference.
  • 🏗️ Automate infrastructure with Terraform, AWS SAM, or CDK.
  • 🗂️ Version prompts with Amazon Bedrock Prompt Management.
  • 👥 Add human review for the most ambiguous cases.

Identifying duplicate or similar products is not just about matching names, but about understanding which attributes define their identity and combining them with business rules. AI can help with the most complex cases, but its real value appears when it is part of a solution that also takes data quality, efficiency, and costs into account.



⚠️ Note: this project is an exploratory  MVP  and is not intended for production use as is:
  • The figures come from a single run on 3,740 products; results may vary with other catalogs.
  • The rules work on the attributes extracted by the model: if the extraction fails, the error propagates.
  • The thresholds, rules, and business criteria were defined empirically and should be adapted and validated with your own data.




8. 📚 References

  1. Adobe. (s. f.). Product information management (PIM).  https://business.adobe.com/blog/perspectives/product-information-management 
  1. Amazon Reviews 2023. (s. f.). Amazon Reviews 2023.  https://amazon-reviews-2023.github.io/ 
  1. Amazon Web Services. (s. f.). Amazon Bedrock pricing. Recuperado el 20 de octubre de 2026, de  https://aws.amazon.com/bedrock/pricing/ 
  1. Amazon Web Services. (s. f.). AWS Step Functions pricing. Recuperado el 20 de octubre de 2026, de  https://aws.amazon.com/step-functions/pricing/ 
  1. IBM. (s. f.). Exploratory data analysis (EDA).  https://www.ibm.com/think/topics/exploratory-data-analysis 
  1. Tukey, J. W. (1977). Exploratory data analysis. Addison-Wesley.
  1. Wikipedia contributors. (s. f.). List of best-selling video game franchises. Wikipedia. Recuperado el 20 de octubre de 2026, de  https://en.wikipedia.org/wiki/List\_of\_best-selling\_video\_game\_franchises 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article