Free online XSPF to PLS converter

An older media player, car stereo, internet-radio application, or streaming tool may require a PLS playlist instead of XSPF. Converting the file changes the playlist index and metadata representation; it does not copy, convert, or modify the referenced audio.

What the XSPF format is

XSPF (XML Shareable Playlist Format) is an XML playlist format used by media players and library applications such as VLC, Clementine, Strawberry, and Audacious. An .xspf file can store track locations plus fields such as title, creator, album, duration, track number, and application-specific metadata.

XSPF normally contains references rather than audio data. A <location> element may contain a local file URI, a relative path, or a web URL. The referenced files must remain available at compatible locations after conversion.

What the PLS format is

PLS is a small INI-style text playlist format supported by many older desktop players, car stereos, portable devices, and internet-radio programs. A standard PLS file contains a [playlist] section, numbered FileN entries, optional TitleN and LengthN values, NumberOfEntries, and Version=2.

PLS is easy to inspect and edit, and it can reference both local media and streams. Its standard fields are much less expressive than XSPF: album, creator, artwork, track number, genre, and custom metadata generally have no dedicated PLS equivalent. Conversion therefore preserves the playlist references but may discard metadata.

Convert with 101convert.com

For a no-install conversion, upload the XSPF file to the free converter on 101convert.com, choose PLS as the output format, and download the resulting file. Open the PLS file in the target application and test several entries, including at least one local file and one stream if both types are present.

Convert with a Python script

A script is useful when you need a repeatable local conversion or want to inspect the generated playlist. Save this as xspf_to_pls.py:

import sys
import xml.etree.ElementTree as ET

source, target = sys.argv[1], sys.argv[2]
root = ET.parse(source).getroot()
tracks = []

for track in root.findall('.//{*}track'):
    location = track.findtext('{*}location')
    if location and location.strip():
        tracks.append((track, location.strip()))

lines = ['[playlist]']
for number, (track, location) in enumerate(tracks, 1):
    location = location.replace('\r', ' ').replace('\n', ' ')
    title = (track.findtext('{*}title') or '').replace('\r', ' ').replace('\n', ' ')
    duration = track.findtext('{*}duration')
    try:
        length = str(int(duration.strip()) // 1000) if duration else '-1'
    except (AttributeError, ValueError):
        length = '-1'
    lines.append(f'File{number}={location}')
    if title:
        lines.append(f'Title{number}={title}')
    lines.append(f'Length{number}={length}')

lines.append(f'NumberOfEntries={len(tracks)}')
lines.append('Version=2')
with open(target, 'w', encoding='utf-8', newline='\n') as output:
    output.write('\n'.join(lines) + '\n')

Run it from a terminal with:

python xspf_to_pls.py input.xspf output.pls

The script uses only Python’s standard library. It preserves the order of tracks, locations, titles, and known durations, while omitting XSPF tracks that have no location. XSPF durations are normally milliseconds; PLS LengthN values are whole seconds, so fractional seconds are truncated and unknown durations become -1.

Use a desktop media player

Some VLC versions can export a loaded playlist through Media → Save Playlist to File. Open the XSPF playlist, choose that command, select PLS if it appears in the format list, and save with a .pls extension. VLC’s available export formats vary by version, so use the script or 101convert.com if PLS is not offered; VLC’s normal media conversion command is for audio or video transcoding, not playlist-format conversion.

Compatibility limitations

• PLS stores references, not media. Moving the PLS file can break relative paths, and moving the audio files can break absolute paths.
• A player may accept web URLs but reject local file:// URIs, or accept ordinary operating-system paths but reject URI encoding. If local entries fail, replace each URI with the path syntax required by that player.
• Spaces and non-ASCII characters are handled inconsistently by older PLS software. UTF-8 output works in many current applications, while some older Windows programs expect the system code page.
• Standard PLS has no reliable fields for most XSPF metadata beyond title and duration. Album, creator, artwork, track number, and custom fields may be lost; the audio files themselves are unchanged.
• Test the generated file in the exact device or application that requires PLS, because PLS support and path parsing are not uniform across players.