# How to Export AAA Data to PBS Format: A Complete Guide to Azeroth Auction Assassin

> Learn how to export AAA data to PBS format and convert auction house data with Azeroth Auction Assassin. Follow our guide to easily transform your items list into PBS compatible strings.

- Repository: [FF14 Advanced Market Search/azerothauctionassassin](https://github.com/ff14-advanced-market-search/azerothauctionassassin)
- Tags: how-to-guide
- Published: 2026-03-01

---

**To export Azeroth Auction Assassin (AAA) data to Point Blank Sniper (PBS) format, click the "Convert AAA to PBS" button in the Item tab, which triggers `convert_to_pbs()` to transform your `items_list` dictionary into PBS-compatible strings and copies the result to your clipboard.**

The `ff14-advanced-market-search/azerothauctionassassin` repository provides a built-in conversion utility that bridges AAA's JSON-based item storage with Point Blank Sniper's specific import format. This guide explains how to export AAA data to PBS format using both the graphical interface and programmatic methods, referencing the actual implementation in [`AzerothAuctionAssassin.py`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/AzerothAuctionAssassin.py).

## Understanding the AAA to PBS Export Workflow

The conversion system relies on three core components working sequentially. First, the UI stores your desired items in `self.items_list`, a dictionary mapping item IDs to price thresholds. When you initiate the export, the `convert_to_pbs()` slot retrieves this data and passes it to `convert_aaa_json_to_pbs()`, which constructs properly formatted PBS strings using item name lookups from [`StaticData/item_names.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json).

The PBS format requires a specific structure: `Snipe^ItemName;;0;0;0;0;0;0;0;price;;#;;`. The converter automatically populates the item name and price fields while maintaining the zero-padding required by Point Blank Sniper's import specification.

## Step-by-Step Guide to Export AAA Data to PBS Format

### Using the GUI Button

The most common method for exporting AAA data to PBS format uses the built-in conversion button:

1. Launch the application and navigate to the **Item** tab.
2. Ensure your items are loaded (either via **Import Item Data** or by manually editing [`desired_items.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/desired_items.json)).
3. Click the **Convert AAA to PBS** button, which triggers the `convert_to_pbs()` method.

```python

# Button implementation in AzerothAuctionAssassin.py (lines 24-30)

self.convert_to_pbs_button = QPushButton("Convert AAA to PBS")
self.convert_to_pbs_button.setToolTip("Convert your AAA JSON list to PBS format.")
self.convert_to_pbs_button.clicked.connect(self.convert_to_pbs)  # Slot connection

```

Upon successful conversion, a `QMessageBox` confirms the operation, and the PBS-formatted string resides in your system clipboard, ready for pasting into Point Blank Sniper.

### Programmatic Conversion via Python

For batch processing or automation, you can export AAA data to PBS format programmatically without manual GUI interaction:

```python
import json
from PyQt5.QtWidgets import QApplication
from AzerothAuctionAssassin import AzerothAuctionAssassin

# Load AAA JSON file (same structure as desired_items.json)

with open("my_aaa_items.json", "r") as f:
    aaa_data = json.load(f)  # Format: {"12345": 12.34, "67890": 56.78}

# Initialize UI (required for statistics lookup)

app = QApplication([])
window = AzerothAuctionAssassin()
window.show()

# Populate internal dictionary manually

window.items_list = aaa_data

# Convert to PBS format

pbs_string = window.convert_aaa_json_to_pbs(window.items_list)

print("PBS output ready for clipboard:")
print(pbs_string)

# Example output: Snipe^Mystic Sword;;0;0;0;0;0;0;0;1200;;#;;

```

This approach bypasses the import dialog while maintaining full access to the conversion logic and item name resolution via `item_statistics`.

### Direct Helper Method Access

If you need only the conversion routine without UI overhead, instantiate the class and call `convert_aaa_json_to_pbs()` directly:

```python
from AzerothAuctionAssassin import AzerothAuctionAssassin

# Create instance

assistant = AzerothAuctionAssassin()

# Load item statistics for name resolution

assistant.item_statistics = assistant.load_item_statistics()

# Example AAA data

aaa_items = {"12345": 1500, "67890": 3000}

# Generate PBS string

pbs_output = assistant.convert_aaa_json_to_pbs(aaa_items)

print(pbs_output)

```

Note that `load_item_statistics()` populates the internal lookup table from [`StaticData/item_names.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json), which is essential for resolving numeric item IDs to human-readable names required by the PBS format.

## Technical Implementation Details

The conversion logic in [`AzerothAuctionAssassin.py`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/AzerothAuctionAssassin.py) (lines 2438–2462) handles the transformation through several precise steps:

```python
def convert_aaa_json_to_pbs(self, json_data):
    pbs_entries = []
    
    for item_id, price in json_data.items():
        # Resolve item name from statistics

        if item_id in self.item_statistics:
            item_name = self.item_statistics[item_id]
            
            # Construct PBS entry: Snipe^Name;;0;0;0;0;0;0;0;price;;#;;

            pbs_entry = f"Snipe^{item_name};;0;0;0;0;0;0;0;{price};;#;;"
            pbs_entries.append(pbs_entry)
    
    # Join all entries into single PBS payload

    return "".join(pbs_entries)

```

The method skips entries without matching names in `item_statistics`, ensuring that only valid, name-resolvable items appear in the final PBS output. The `convert_to_pbs()` wrapper (lines 2423–2435) then copies this string to the clipboard using `QApplication.clipboard().setText()`, completing the export workflow.

## Summary

- **Primary Method**: Click **Convert AAA to PBS** in the Item tab to instantly convert your `items_list` to PBS format and copy it to the clipboard.
- **Data Structure**: The converter reads `self.items_list` (a dictionary of `item_id: price` pairs) and resolves names via [`StaticData/item_names.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json).
- **Output Format**: PBS entries follow the pattern `Snipe^ItemName;;0;0;0;0;0;0;0;price;;#;;`, concatenated into a single import string.
- **Automation**: Use `convert_aaa_json_to_pbs()` programmatically for batch processing without GUI interaction.

## Frequently Asked Questions

### What is the PBS format used for in Azeroth Auction Assassin?

The PBS (Point Blank Sniper) format is a specific text format required by the Point Blank Sniper addon for World of Warcraft. When you export AAA data to PBS format, you generate a string that the addon can parse to configure its sniping behavior, allowing you to import your Azeroth Auction Assassin price thresholds directly into the in-game tool.

### Can I convert AAA data to PBS format without opening the GUI?

Yes, you can export AAA data to PBS format programmatically by instantiating the `AzerothAuctionAssassin` class and calling `convert_aaa_json_to_pbs()` directly. You must first populate `self.item_statistics` by calling `load_item_statistics()` or manually loading [`StaticData/item_names.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json), as the converter requires item name resolution to generate valid PBS strings.

### Why are some items missing from my PBS export?

Items missing from the PBS output typically lack entries in the `item_statistics` dictionary, which is populated from [`StaticData/item_names.json`](https://github.com/ff14-advanced-market-search/azerothauctionassassin/blob/main/StaticData/item_names.json). The `convert_aaa_json_to_pbs()` method explicitly skips any `item_id` that cannot be resolved to a human-readable name, ensuring that only valid, name-resolvable items appear in the final Point Blank Sniper import string.

### How do I batch process multiple AAA JSON files into PBS format?

To batch export AAA data to PBS format, write a Python script that iterates over your JSON files, instantiates `AzerothAuctionAssassin` once to load the statistics cache, and calls `convert_aaa_json_to_pbs()` for each file's contents. Write the returned PBS strings to separate text files or combine them depending on your Point Blank Sniper import requirements. This approach avoids the overhead of launching the GUI for each conversion.