Skip to main content

​
Overview

The Bet365MessageParser class provides functionality to parse and query Bet365’s proprietary message format. This format is used in API responses and consists of sections separated by delimiters, with each section containing a type and key-value properties.

​
Class: Bet365MessageParser

​
Constructor

Bet365MessageParser(sections: List[List[Bet365Section]])
​
sections
List[List[Bet365Section]]
required
A list of section groups, where each group is a list of Bet365Section objects
Example: 
from bet365.message_parser import Bet365MessageParser, Bet365Section

# Usually created via get_parsers(), not directly
sections = [[
    Bet365Section("CL", {"NA": "Soccer", "PD": "#AS#B1#"}),
    Bet365Section("MA", {"FD": "Match Name"})
]]

parser = Bet365MessageParser(sections)

​
Static Methods

​
parse_section_string()

Parses a single section string into a Bet365Section object. 
@staticmethod
def parse_section_string(section_string: str) -> Bet365Section
​
section_string
str
required
String in format "TYPE;key1=value1;key2=value2"
Returns: Bet365Section - Parsed section object Example: 
from bet365.message_parser import Bet365MessageParser

section = Bet365MessageParser.parse_section_string(
    "CL;NA=Soccer;PD=#AS#B1#C1#D8#;ID=12345"
)

print(section.type)  # Output: CL
print(section.get_property("NA"))  # Output: Soccer
print(section.get_property("PD"))  # Output: #AS#B1#C1#D8#

​
parse_sections_list()

Parses a list of section strings into Bet365Section objects. 
@staticmethod
def parse_sections_list(sections_list: List[str]) -> List[Bet365Section]
​
sections_list
List[str]
required
List of section strings to parse
Returns: List[Bet365Section] - List of parsed section objects Example: 
section_strings = [
    "CL;NA=Soccer;PD=#AS#B1#",
    "MA;FD=Team A vs Team B",
    "PA;OD=3/1;ID=98765"
]

sections = Bet365MessageParser.parse_sections_list(section_strings)

for section in sections:
    print(f"{section.type}: {section.properties}")

​
Instance Methods

​
find_sections()

Finds sections matching specified criteria across all section groups. 
def find_sections(
    node_type: str,
    include_part_index: bool = False,
    **filters
) -> Iterator[Tuple[int, Bet365Section]]
​
node_type
str
required
The section type to search for (e.g., “CL”, “MA”, “PA”, “MG”)
​
include_part_index
bool
default:"False"
If True, yields the section itself. If False, yields the entire section group.
​
**filters
Any
Property filters to apply. Can be exact values or callable functions for custom matching.
Returns: Iterator[Tuple[int, Bet365Section]] - Iterator of (index, section) tuples Example: 
# Find all CL sections with a specific name
for idx, section in parser.find_sections("CL", NA="Soccer", include_part_index=True):
    print(f"Found at index {idx}: {section.get_property('NA')}")

# Find sections using a custom filter function
def has_odds(key, value):
    return value is not None and "/" in str(value)

for idx, section in parser.find_sections("PA", OD=has_odds, include_part_index=True):
    print(f"Odds: {section.get_property('OD')}")

# Find sections with PV property starting with specific value
for idx, section in parser.find_sections(
    "CL",
    PV=lambda k, v: v.startswith("podcontentcontentapi") if v else False,
    include_part_index=True
):
    print(f"Found pod content section at {idx}")

​
Module Functions

​
get_parsers()

Creates parser instances from raw Bet365 API response data. 
def get_parsers(data: str) -> List[Bet365MessageParser]
​
data
str
required
Raw response data from Bet365 API (uses \b and | as delimiters)
Returns: List[Bet365MessageParser] - List of parser instances Example: 
from bet365.message_parser import get_parsers
from bet365 import Bet365AndroidSession

session = Bet365AndroidSession(
    api_url="https://api.example.com/generate",
    api_key="your-api-key"
)

session.go_homepage()
response = session.protected_get(
    f"https://{session.host}/leftnavcontentapi/allsportsmenu",
    params={"lid": "30", "zid": "0"},
    headers={"X-b365App-ID": "8.0.36.00-row"}
)

# Parse the response
parsers = get_parsers(response.text)

for parser in parsers:
    # Find all sport sections
    for idx, section in parser.find_sections("CL", include_part_index=True):
        name = section.get_property("NA")
        if name:
            print(f"Sport: {name}")

​
read_table()

Extracts table data from a parser starting at a specific index. 
def read_table(
    parser: Bet365MessageParser,
    idx: int,
    extra_properties: list = []
) -> Dict[str, Any]
​
parser
Bet365MessageParser
required
Parser instance containing the table data
​
idx
int
required
Starting index of the table (usually points to an MG section)
​
extra_properties
list
default:"[]"
Additional property keys to extract from sections
Returns: Dict[str, Any] - Dictionary containing:
  • title (str): Table title
  • data (list): List of rows, each with name, values, and extra fields
Example: 
from bet365.message_parser import get_parsers, read_table

response = session.protected_get(...)
parsers = get_parsers(response.text)

for parser in parsers:
    # Find match group sections
    for idx, _ in parser.find_sections("MG", include_part_index=True):
        table = read_table(parser, idx, extra_properties=["IT", "CT"])
        
        print(f"Table: {table['title']}")
        for row in table['data']:
            print(f"  {row['name']}: {row['values']}")
            if row['extra']:
                print(f"    Extra: {row['extra']}")

​
Complete Example

from bet365 import Bet365AndroidSession
from bet365.message_parser import get_parsers, read_table
from bet365.utils import parse_odds

# Initialize and setup session
session = Bet365AndroidSession(
    api_url="https://api.example.com/generate",
    api_key="your-api-key"
)
session.go_homepage()

# Get sports list
response = session.protected_get(
    f"https://{session.host}/leftnavcontentapi/allsportsmenu",
    params={
        "lid": "30",
        "zid": "0",
        "pd": "#AL#B1#R^1#",
    },
    headers={"X-b365App-ID": "8.0.36.00-row"}
)

# Parse response
parsers = get_parsers(response.text)

for parser in parsers:
    # Find all classification sections
    for idx, cl in parser.find_sections(
        "CL",
        include_part_index=True
    ):
        sport_name = cl.get_property("NA")
        sport_pd = cl.get_property("PD")
        
        if sport_name and sport_pd:
            print(f"\nSport: {sport_name}")
            print(f"PD: {sport_pd}")
            
            # Check if it has an ID
            if cl.has_property("ID"):
                print(f"ID: {cl.get_property('ID')}")

​
Section Types

Common section types you’ll encounter:
  • CL (Classification): Sport/category information
  • MA (Market): Betting market or match name
  • PA (Participant): Team/player with odds
  • MG (Match Group): Container for match tables
  • CO (Comment): Additional context or labels
  • F (Delimiter): Marks the end of a data block

Build docs developers (and LLMs) love

Get started for freeTalk to us