How to Use Item Level Sniping in Azeroth Auction Assassin: A Complete Guide

Azeroth Auction Assassin targets BOE gear by item level through a three-layer system: an HTML form panel for rule creation, JavaScript handlers for JSON import/export, and a Python backend that validates rules and filters auction house scans against your criteria.

The ff14-advanced-market-search/azerothauctionassassin repository provides a dedicated "Item Level Rules" panel that lets you snipe specific gear pieces based on ilvl ranges, bonus lists (sockets, speed, leech, avoidance), and buyout price limits. This feature is particularly useful for finding high-value raid BOEs or twink gear that matches exact character requirements.

How Item Level Sniping Works

The implementation relies on three distinct layers that pass data from the user interface to the auction scanner:

Layer	Function	Source Location
UI Definition	HTML form fields for ilvl, max_ilvl, buyout, item_ids, and bonus toggles	node-ui/index.html (lines 445-474)
Front-end Logic	JavaScript event listeners for import/export/reset buttons that serialize rules into JSON	node-ui/renderer.js (lines 104-115)
Back-end Processing	Python validation and conversion of JSON rules into scanner-compatible snipe-info dictionaries	utils/mega_data_setup.py in the MegaData class

When you click Export in the UI, the JavaScript writes your rules to AzerothAuctionAssassinData/desired_ilvl_list.json. On application startup, the MegaData.__set_desired_ilvl_list method parses this file, groups entries by ilvl, resolves item names via get_ilvl_items(), and stores validated rules in self.DESIRED_ILVL_LIST. The auction scanner in mega_alerts.py then iterates over this list (lines 315-322) to filter live auction data.

Configuring Item Level Rules via the UI

The Item Level Rules Panel

The interface provides a vertical form inside the Item Level Rules card where you define sniping parameters. The form captures minimum and maximum item levels, maximum buyout price in copper, specific item IDs, and boolean flags for desired tertiary stats.

Key input fields include:

• ilvl and max_ilvl: Define the acceptable item level range (e.g., 470 to 470 for exact matches)
• buyout: Maximum price in copper (e.g., 150001 for 15 gold)
• item_ids: Comma-separated list of specific item IDs to target
• bonus_lists: Array of bonus IDs for specific affixes
• sockets, speed, leech, avoidance: Boolean toggles for tertiary stats

These fields are defined in node-ui/index.html within the ilvl-form element.

Importing and Exporting Rule Sets

The application persists your rules through JSON files. The front-end logic attaches click handlers to three specific buttons:

• Import: Loads desired_ilvl_list.json from disk into the UI table
• Export: Writes the current in-memory ilvlList array to AzerothAuctionAssassinData/desired_ilvl_list.json
• Reset: Clears the current rule set

This wiring occurs in node-ui/renderer.js where the import-ilvl-btn, export-ilvl-btn, and reset-ilvl-btn elements receive their event listeners.

Understanding the JSON Data Format

For advanced users or bulk configuration, you can edit desired_ilvl_list.json directly. The backend expects an array of objects with specific required keys.

Sample Rule Structure

{
  "ilvl": 470,
  "max_ilvl": 470,
  "buyout": 150001,
  "sockets": false,
  "speed": false,
  "leech": false,
  "avoidance": false,
  "item_ids": [208426, 208428, 208431],
  "bonus_lists": [],
  "required_min_lvl": 1,
  "required_max_lvl": 999
}

This example targets exactly item level 470 with a maximum buyout of roughly 15 gold, restricted to three specific item IDs, with no tertiary stat requirements. The full example file is available at AzerothAuctionAssassinData/example_desired_ilvl_list.json (lines 3-10).

Data Flow Validation

The MegaData class performs strict validation when loading this JSON:

• Checks for required keys (ilvl, max_ilvl, buyout)
• Normalizes boolean values for tertiary stats
• Converts item IDs to integers
• Groups entries by ilvl for efficient scanning

If the JSON file is missing, the system falls back to an environment variable path or returns an empty list.

Backend Processing and Auction Scanning

MegaData Class Initialization

The Python backend handles rule persistence through the MegaData class defined in utils/mega_data_setup.py (lines 23-30). During initialization, it calls the private method __set_desired_ilvl_list (lines 320-387) to hydrate the rule set.

class MegaData:
    def __init__(self, path_to_desired_ilvl_list=None):
        # Additional initialization...

        self.DESIRED_ILVL_LIST = self.__set_desired_ilvl_list(path_to_desired_ilvl_list)
    
    def __set_desired_ilvl_list(self, path_to_data=None):
        # Loads JSON from path or environment variable

        # Resolves item names and base ilvls via get_ilvl_items()

        # Validates and normalizes all rule parameters

        # Returns list of snipe-info dictionaries

        pass

This method transforms your JSON rules into optimized snipe-info dictionaries that the scanner consumes. It also handles item name resolution so the alert messages display human-readable gear names rather than just IDs.

Auction Scanner Implementation

The live scanning logic resides in mega_alerts.py (lines 315-322). For each auction item retrieved from the Blizzard API, the scanner iterates through mega_data.DESIRED_ILVL_LIST and applies Boolean filters:

for desired_ilvl_item in mega_data.DESIRED_ILVL_LIST:
    if (item_ilvl >= desired_ilvl_item['ilvl'] and 
        item_ilvl <= desired_ilvl_item['max_ilvl'] and 
        item_buyout <= desired_ilvl_item['buyout'] and 
        (desired_ilvl_item['sockets'] is None or item_has_socket)):
        # Trigger alert notification

        pass

The scanner respects both hard numeric limits (ilvl ranges, buyout caps) and tertiary stat presence (sockets, speed, leech, avoidance). This ensures you only receive alerts for items that exactly match your character's gearing needs or your resale criteria.

Summary

• Item level sniping in Azeroth Auction Assassin requires creating rules in the UI panel or editing desired_ilvl_list.json directly with specific ilvl ranges, buyout limits, and tertiary stat flags.
• The three-layer architecture separates UI presentation (node-ui/index.html), data persistence (renderer.js), and scanning logic (mega_data_setup.py and mega_alerts.py).
• Rules are validated and normalized by the MegaData.__set_desired_ilvl_list method, which resolves item names and groups entries for efficient filtering.
• The auction scanner iterates over DESIRED_ILVL_LIST during each API poll, comparing live auction items against your criteria to trigger alerts only for exact matches.

Frequently Asked Questions

What file format does Azeroth Auction Assassin use for item level rules?

The application uses standard JSON arrays stored in AzerothAuctionAssassinData/desired_ilvl_list.json. Each array element is an object containing keys for ilvl, max_ilvl, buyout, item_ids, bonus_lists, and boolean flags for sockets, speed, leech, and avoidance. You can generate this file manually or export it from the built-in UI panel.

Where are item level sniping rules stored in the codebase?

Rule definitions exist in three locations: the HTML form structure in node-ui/index.html (lines 445-474), the import/export JavaScript handlers in node-ui/renderer.js (lines 104-115), and the Python validation logic in utils/mega_data_setup.py within the MegaData class (lines 23-30 and 320-387). The actual data file lives in the AzerothAuctionAssassinData directory.

Can I filter for specific item IDs when using ilvl sniping?

Yes. The item_ids field accepts a comma-separated list (stored as a JSON array) that restricts alerts to specific gear pieces. If you leave item_ids empty, the scanner matches any item within the specified ilvl and buyout range regardless of the specific gear slot or appearance.

How does the scanner handle bonus lists like sockets and speed?

The scanner treats tertiary stats as Boolean filters in the mega_alerts.py loop (lines 315-322). If you set sockets: true in your rule, the code verifies that the auction item actually has a socket bonus before triggering an alert. If you set the value to false or null, the scanner ignores that tertiary stat entirely, matching items both with and without the bonus.

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