How to Find Item IDs for desired_items.json in AzerothAuctionAssassin

To find item IDs for desired_items.json, search the StaticData/item_names.json lookup table for your item name and use the corresponding numeric key as the ID in your configuration.

The AzerothAuctionAssassin monitors World of Warcraft auction houses by reading item IDs from desired_items.json. This guide explains how to locate the correct numeric identifiers using the repository's built-in lookup tables and source code structure.

Understanding the desired_items.json Format

desired_items.json is a user-supplied configuration file that maps item IDs to your desired price thresholds or quantities. The application loads this file during initialization through the MegaDataSetup class in [utils/mega_data_setup.py](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/utils/mega_data_setup.py).

Specifically, the private method __set_desired_items (lines 315‑318) reads the JSON file, converts each string key to an integer, and stores the result in the DESIRED_ITEMS attribute. The value for each ID should be a float representing your price in copper or your desired quantity threshold.

Locating Item IDs in the Static Data

Using item_names.json

The repository includes a comprehensive lookup table at [StaticData/item_names.json](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json). This file contains a JSON object where every key is a numeric item ID and every value is the human-readable item name.

For example:

{
  "194641": "Giant-sized Sword",
  "192458": "Dragonscale Expedition's Expedition Gear"
}

Step-by-Step Lookup Process

1. Open the lookup table – Navigate to StaticData/item_names.json in your local clone or the GitHub repository.

2. Search for your item – Use your editor's search function (Ctrl+F) to find the item by partial or full name.

3. Copy the numeric key – The key associated with the item name is the ID you need for desired_items.json.

4. Verify with the example file – Check [AzerothAuctionAssassinData/example_desired_items.json](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/AzerothAuctionAssassinData/example_desired_items.json) to confirm the correct JSON structure.

Adding Items to Your Configuration

File Location and Structure

Place your completed desired_items.json file in the AzerothAuctionAssassinData/ directory. The JSON structure requires string keys (the item IDs) mapped to numeric values (prices in copper):

{
  "194641": 500000,
  "192458": 1000000
}

In this example, 500000 represents 50 gold (since 1 gold = 10,000 copper).

Code Example for Automated Lookup

If you prefer to automate the process, use this Python script to search item_names.json and append entries to your desired_items.json:

import json
from pathlib import Path

# Load the static ID-to-name map

static_data_path = Path(__file__).parent.parent / "StaticData" / "item_names.json"
with open(static_data_path) as f:
    id_to_name = json.load(f)

# Find the ID for a given item name (case-insensitive partial match)

def find_item_id(search_name):
    search_lower = search_name.lower()
    for item_id, item_name in id_to_name.items():
        if search_lower in item_name.lower():
            return int(item_id)
    raise ValueError(f"Item '{search_name}' not found in the lookup table.")

# Path to your desired items configuration

desired_items_path = Path(__file__).parent.parent / "AzerothAuctionAssassinData" / "desired_items.json"

# Load existing desired items or create empty dict

desired = {}
if desired_items_path.exists():
    with open(desired_items_path) as f:
        desired = json.load(f)

# Example: Add "Righteous Sword" with a price of 50 gold (500000 copper)

item_name = "Righteous Sword"
item_id = find_item_id(item_name)
desired[str(item_id)] = 500000  # Price in copper

# Save updated configuration

with open(desired_items_path, "w") as f:
    json.dump(desired, f, indent=2, sort_keys=True)

print(f"Added {item_name} (ID: {item_id}) to desired_items.json")

How the Application Loads Your Items

When the AzerothAuctionAssassin starts, the MegaDataSetup class initializes the configuration. The private method __set_desired_items in utils/mega_data_setup.py specifically handles desired_items.json:

• It opens the file from the AzerothAuctionAssassinData/ directory
• It converts all JSON keys from strings to integers (lines 315‑318)
• It stores the final mapping in the DESIRED_ITEMS attribute for use by the auction scanning logic

This means your JSON keys must be valid numeric strings that correspond to actual World of Warcraft item IDs found in StaticData/item_names.json.

Summary

• desired_items.json maps item IDs to your target prices and must be placed in AzerothAuctionAssassinData/.
• Item IDs are numeric identifiers found in StaticData/item_names.json, where the key is the ID and the value is the item name.
• The application loads these IDs through utils/mega_data_setup.py in the __set_desired_items method, converting string keys to integers for internal use.
• Always use the static lookup table to verify IDs before adding them to your configuration to ensure the Assassin monitors the correct items.

Frequently Asked Questions

Where is the item ID database located?

The master lookup table is stored at StaticData/item_names.json in the repository root. This file contains every valid World of Warcraft item ID mapped to its display name, serving as the authoritative source for configuring your desired_items.json.

What format does desired_items.json require?

The file requires a simple JSON object where keys are string representations of numeric item IDs and values are floats representing your desired price in copper. For example: {"194641": 500000}. The application parses this in utils/mega_data_setup.py and converts the keys to integers internally.

Can I use item names instead of IDs in the configuration?

No, the MegaDataSetup class strictly requires numeric item IDs. The __set_desired_items method converts JSON keys to integers, and the auction house API calls rely on these numeric identifiers. You must translate item names to IDs using StaticData/item_names.json before adding entries to your configuration file.

How do I verify my item IDs are correct?

Cross-reference your IDs against StaticData/item_names.json to confirm the numeric key matches your intended item name. You can also check the example file at AzerothAuctionAssassinData/example_desired_items.json to verify your JSON syntax matches the expected structure before the application loads it via utils/mega_data_setup.py.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}