The Ultimate Guide

Master every advanced feature, gesture, and tool available in the PHP Music platform.

1. Playback & Core Navigation

Instant Playback
Simply click or tap on any song row in any list, album, or playlist. The audio will immediately stream, and the persistent player bar will appear at the bottom of your screen.
Fullscreen Mode & Visualizer
Click the square album artwork inside the bottom player bar. This triggers the immersive Fullscreen Player, which features an audio-reactive visualizer that bounces to the beat, synced lyrics, and the Up Next queue.
Seek Gestures
Click and hold (long press) the Next or Previous buttons. This will seamlessly fast-forward or rewind the currently playing track in precise 5-second increments.
Picture-in-Picture (PiP) Mini Player
On desktop, click the icon to detach the player into a floating window. It stays visible over all other tabs and applications, complete with interactive playback controls and real-time scrolling lyrics!
Sleep Timer & Wake Lock
Open your profile dropdown (top right) and select "Sleep Timer". Enter the number of minutes, and the music will gracefully pause when time is up. You can optionally toggle the Wake Lock icon to physically prevent your phone screen from dimming while you read lyrics.

2. The Advanced Audio Engine

5-Band Equalizer & Crossfade
Inside the Settings menu, toggle the Equalizer to sculpt the frequencies (Bass, Mids, Treble). You can also adjust the Crossfade slider to seamlessly blend the end of one song into the beginning of the next!
Volume Normalization (AGC)
Enabled by default, Automatic Gain Control ensures that quiet songs and loud songs play at the exact same volume level, eliminating the need to constantly adjust your speakers.
3D Spatial Audio (HRTF)
Enable this toggle in Settings to process the stereo signal through a Head-Related Transfer Function, simulating a surround-sound room environment for headphone users.
Per-Song Overrides
If a specific song was mastered poorly, open its Context Menu and click "Audio Settings (This Song)". You can set a unique volume multiplier and EQ curve that will permanently trigger only when that specific song plays!

3. Multi-Select Mode

Activating Selection Mode
To manage many songs at once, press and hold (long-click) on any song row for exactly 1 second. A translucent red highlight will appear, and a floating toolbar will slide up from the bottom of your screen.
Selecting Multiple Tracks
Once activated, you can tap on any other song rows to add them to your selection bundle. You can also click the icon in the floating bar to instantly select every track currently loaded on the screen.
Bulk Actions
Click the three dots on the floating bar. From here, you can instantly inject all selected tracks into a Playlist, dump them into your Favorites, forcefully Cache them for Offline playback, or Bulk Delete them!

4. Playlists & Organization

Public vs. Private Playlists
When creating a playlist, you can toggle privacy. Public playlists can be searched and viewed by anyone, while Private playlists are strictly visible only to your account.
Collaborative Sessions
Open your playlist's menu and select "Make Collaborative". You can then click "Manage Collaborators" and invite friends by typing their exact Username or Email. They will instantly gain the ability to add, reorder, and remove tracks in your playlist!
Drag and Drop Sorting
When viewing your Playlists, Favorites, or Offline library, ensure the sort dropdown is set to "My Order". You can then seamlessly drag and drop songs up and down the list. The database saves your new arrangement automatically!
Intelligent Filtering
Use the Sort Dropdown located at the top right of the interface to instantly reorganize massive lists by Title, Artist, Album, Release Year, or Recently Added.

5. Offline Library & Caching

Installing the App (PWA)
Click "Install App" in the sidebar. This registers PHP Music as a Progressive Web App directly onto your Home Screen, bypassing the browser UI, accelerating load times via Service Workers, and enabling true disconnected offline usage.
Downloading Tracks
Open a song's menu and select "Make Available Offline". The audio stream and album art will physically download into your browser's encrypted Storage Quota. A green checkmark will confirm it is secure.
Cache Management & Warnings
If your device runs extremely low on storage, iOS/Android might silently delete cache chunks. If a song shows a warning , simply click "Re-download Cache" to repair the file, or use "Re-cache All" in the Offline view.

6. Community & Interaction

Global Community Feed
Access the Community tab to broadcast text posts to all users on the server. You can edit, delete, and Like/Dislike posts globally.
Song Threads & Mentions
Every single track contains a dedicated comment section. Open the song menu and click "View Comments". You can reply to specific users, use @Username to tag them, and vote on track popularity.
Following Users
Click the "Follow" button on any user's profile. Their newly uploaded songs and albums will automatically surface in your personalized "For You" feed!
Personal Notes
Need to write down a lyric draft or a diary entry while listening? Use the Personal Notes tab. These notes are completely private, heavily encrypted in the database, and timestamped upon modification.

7. Uploading & Deep Metadata

Upload Pipeline
Verified users can upload up to 10 tracks daily. The system accepts MP3, FLAC, M4A, OGG, and WAV. The server automatically parses the ID3 Tags (Title, Artist, Album, Genre) and extracts embedded Cover Art during upload.
Live Metadata Editor
If the automated ID3 parsing is incorrect, click "Edit Info" on any song you uploaded. You can dynamically overwrite the database fields and attach a new cover art file (which will be perfectly 1:1 cropped using the CropperJS engine).
Synchronized LRC Lyrics
When editing Metadata, you can paste standard [mm:ss.xx] LRC format strings into the Lyrics box. The player engine will automatically parse these timestamps and scroll the lyrics perfectly to the audio track during playback!

8. Data Portability & Downloads

JSON Library Exports
Never lose your curated lists. Navigate to any Playlist, your Favorites, or your Offline Library, and click the Export button. The server generates a lightweight `.json` manifest that can be imported to perfectly reconstruct the list anywhere.
The Playlist Downloader
Open the Downloader tool from the sidebar. Paste the Public ID of any playlist, and the system will queue all tracks. Click "Start Sequential Download" to rip the physical MP3s directly to your hard drive, one by one.
Cryptographic Account Backups
In Settings, you can choose to "Delete Account but Keep Data". The server destroys your email/password logic, turns you into an anonymous ghost account, and provides a complex Backup Key. Keep this key safe 🔑 — you can enter it into the "Restore Account" module later to reclaim your exact library under a totally different name!

9. Developer & Power-User Tools

Open API Endpoints
Click "Get API" in the sidebar. This tool reveals all the internal backend URL hooks (e.g., ?action=get_songs). You can copy these endpoints to write python scripts, discord bots, or external UI interfaces that tap directly into your PHP Music database.
Full Library Scan
If a server administrator physically drags thousands of MP3s into the server folder using FTP, they can trigger a "Scan All" from the sidebar. The engine sweeps the directory tree, analyzes every ID3 tag, and aggressively injects them into the SQLite database.
Clear Application Cache
If the player starts acting buggy or storage quota is overloaded, click "Clear Cache" in the sidebar. This securely unregisters Service Workers, deletes old Offline caches, resets DOM memory, and forces a hard reload of the interface.

10. Core Icon Dictionary

Play / Pause: Tap to toggle audio playback state.

Prev / Next: Skip tracks, or hold to scrub the timeline.

Shuffle: Randomize the play queue securely.

Repeat: Cycle (Off ➡️ Repeat All ➡️ Repeat One).

Context Menu: Access sharing, metadata, and playlist tools.

Favorite: Pin a song globally to your profile collection.

11. Disclaimers & Fair Use

Copyright Responsibility: Users are solely responsible for the audio files they upload. Ensure you have the explicit right, license, or explicit permission from the original artist to use, stream, and distribute the content on this instance.

Personal Use Only: Advanced scraping utilities, including the Playlist Downloader, Open API, and high-quality streaming engines, are intended strictly for personal, private, and entirely non-commercial listening curation.

Content Moderation: Instance administrators reserve the unconditional right to instantly terminate sessions, indefinitely ban accounts, remove files, or delete altered metadata that violates copyright laws or general community guidelines without any prior notice.

Use these markdown formats to style your personal notes. Toggle the button in the editor to see the preview!

Element Syntax Example Preview

Headings # H1 ## H2 ### H3 H1
H2

Bold **bold text** bold text

Italic *italicized text* italicized text

Strikethrough ~~strikethrough~~ ~~strikethrough~~

Blockquote

> blockquote

blockquote

Ordered List

1. First item
2. Second item

First item
Second item

Unordered List

- First item
- Second item

First item
Second item

Task List

- [ ] To do
- [x] Done

To do
Done

Code `code` code

Code Block

```
code block
```

code block

Link [title](https://url.com) title

Image ![alt](https://img.url) image

Table

| Col | Col |
| --- | --- |
| Val | Val |

Col	Col
Val	Val

Align Left

<div style="text-align: left;">Left</div>

Left

Align Center

<div style="text-align: center;">Center</div>

Center

Align Right

<div style="text-align: right;">Right</div>

Right

Resize Image <img src="url" width="50%" height="auto"> Resized Image

Video / YouTube <video src="..."> or <iframe> Embedded Video

Horizontal Rule

---

Master the Beat

Learn the core mechanics, note types, and scoring system to climb the leaderboards.

Note Types

Tap Notes (Cyan) The standard note. Tap the corresponding lane key exactly when the note aligns with the red judgment line at the bottom.

Hold Notes (Green) Press and hold the key when the bottom of the note reaches the line, and release it exactly when the top tail passes. Letting go too early breaks your combo.

Flick Notes (Pink) Swipe up or quickly flick your finger/mouse on the lane when it hits the line. On desktop, releasing the key rapidly counts as a flick.

Hold + Flick Notes A combination of Hold and Flick. Keep the key pressed during the transparent body, and release it with a flick/swipe exactly as the pink tail passes the judgment line.

Navigation & Difficulties

Hub Navigation: Use the bottom navigation bar to switch between Songs, Artists, Favorites, Ranks, your Profile, or Offline tracks.
Difficulty Scaling:
- Easy / Normal: Uses 4 lanes (D, F, J, K). Best for beginners.
- Hard / Expert / Master: Uses 6 lanes (S, D, F, J, K, L). Requires faster reaction times.
- Demon: Uses all 10 lanes! Requires Landscape orientation on mobile devices.
Autoplay (Bot Mode): Toggle "Autoplay" on the song menu to let the bot achieve a perfect score automatically. Note: Autoplay scores are not saved to the leaderboards.

Scoring & Ranks

PERFECT

🎯 ±45ms

100% Acc

GREAT

✨ ±80ms

75% Acc

GOOD

👍 ±125ms

40% Acc

BAD / MISS

❌ >125ms

Breaks Combo

SS (98%+) S (95%+) A (90%+) B (80%+) C (70%+)

Tips & Settings

Calibration: If notes feel out of sync with the beat, use the Calibration Tool in the Settings tab to adjust your audio offset (in milliseconds).
Note Speed: Adjusting the Tick Speed in settings spreads the notes further apart, making fast sections easier to read without altering the song's BPM.
HP Bar: Missing notes drains your green health bar. If it empties completely, you fail the stage!
Anti-Cheat: The server actively detects inhuman macros and auto-clickers. Do not use scripts, or you will be permanently banned.

JUMP TO ENDPOINT

Live Request Playground

Select an endpoint below to immediately generate the secure URL string and test the live JSON response returned straight from your SQLite database. The iframe below executes the generated query using your locally cached Admin Key.

YOUR API KEY

ENDPOINT ACTION

GENERATED ENDPOINT URL GET

Required JSON Body Payload

PHP Music Core API

Welcome to the comprehensive reference documentation. This manual details the endpoints for querying database entities, streaming byte ranges, extracting binary blobs, and manipulating state via the RESTful JSON interface. All endpoints are protected by CORS firewalls and require strict Master Key authentication to access externally.

GET

Retrieve All Songs

GET /?access=api&action=get_songs&api_key=YOUR_ADMIN_KEY

Overview

This is the primary pipeline for fetching your music library. It retrieves a highly optimized, paginated array of song entities from the SQLite database. The backend automatically enforces strict privacy checks, entirely omitting tracks marked as is_private=1 unless the filter_user_id specifically matches the track owner, or the global api_key bypass is initiated. Furthermore, it dynamically computes and attaches the play_count integer by executing a fast subquery against the play_counts relationship table.

Query Parameters

Parameter	Type	Required	Description
`access`	string	Yes	Must be exactly `api` to bypass the HTML renderer and trigger the JSON header response.
`action`	string	Yes	Must be exactly `get_songs`.
`api_key`	string	Yes	The master Admin Password established in `index.php`. Requests without this will drop a 401 Unauthorized block.
`page`	integer	No	Pagination multiplier. Defaults to `1`. Multiplies against the global `PAGE_SIZE` constant (25).
`sort`	string	No	Determines the ORDER BY clause. Options: `id_desc`, `id_asc`, `artist_asc`, `title_asc`, `album_asc`, `year_desc`. Defaults to `id_desc`.
`artist`	string	No	URL Encoded artist name. Filters the database using the internal `match_artist()` custom SQLite function for precise collision detection.
`filter_user_id`	integer	No	Limits results strictly to tracks uploaded by this specific integer User ID.

Code Integration Examples

const fetchLibrary = async () => {
  const endpoint = 'https://yourdomain.com/?access=api&action=get_songs&api_key=YOUR_API_KEY&page=1&sort=title_asc';
  
  try {
    const response = await fetch(endpoint, {
      method: 'GET',
      headers: { 'Accept': 'application/json' }
    });
    
    if (!response.ok) {
      throw new Error(`HTTP Error: ${response.status}`);
    }
    
    const songs = await response.json();
    console.log(`Successfully fetched ${songs.length} tracks.`);
    
    // Map over the results
    songs.forEach(song => {
      console.log(`[${song.id}] ${song.title} - ${song.artist} (${song.duration}s)`);
    });
    
  } catch (error) {
    console.error('API Pipeline failed:', error);
  }
};

fetchLibrary();

import requests
import json

def get_all_songs():
    url = "https://yourdomain.com/"
    
    payload = {
        "access": "api",
        "action": "get_songs",
        "api_key": "YOUR_API_KEY", # Replace with actual key
        "page": 1,
        "sort": "title_asc"
    }
    
    try:
        response = requests.get(url, params=payload, timeout=10)
        response.raise_for_status() # Trigger exception for 4xx/5xx errors
        
        data = response.json()
        print(f"Acquired {len(data)} music objects.")
        print(json.dumps(data[0], indent=2)) # Print first object beautifully
        
    except requests.exceptions.RequestException as e:
        print(f"Fatal System Error: {e}")

get_all_songs()

<?php
$url = "https://yourdomain.com/?access=api&action=get_songs&api_key=YOUR_API_KEY&page=1";

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json'));
curl_setopt($ch, CURLOPT_TIMEOUT, 15);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Ignore if self-signed cert

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

if (curl_errno($ch)) {
    echo "cURL Error: " . curl_error($ch);
} elseif ($httpCode !== 200) {
    echo "HTTP Blocked: " . $httpCode;
} else {
    $songs = json_decode($response, true);
    print_r($songs);
}
curl_close($ch);
?>

Expected JSON Response (HTTP 200 OK)

Returns an array of JSON objects. If the query yields no results, it strictly returns an empty array [], never null.

[
  {
    "id": 1042,
    "title": "Stairway to Heaven",
    "artist": "Led Zeppelin",
    "album": "Led Zeppelin IV",
    "genre": "Classic Rock",
    "duration": 482,
    "user_id": 1,
    "is_private": 0,
    "last_modified": 1698765432,
    "is_favorite": 1,
    "play_count": 8750
  },
  {
    "id": 1043,
    "title": "Hotel California",
    "artist": "Eagles",
    "album": "Hotel California",
    "genre": "Rock",
    "duration": 390,
    "user_id": 2,
    "is_private": 0,
    "last_modified": 1698765999,
    "is_favorite": 0,
    "play_count": 6420
  }
]

Error Responses & Troubleshooting

HTTP 401 Unauthorized: Thrown if the api_key parameter is entirely missing, blank, or cryptographically invalid against the server's Master Password.

{
  "status": "error",
  "message": "API access denied. Valid api_key (Admin Password) required."
}

HTTP 429 Too Many Requests: Thrown if your script requests the endpoint more than 150 times within a 60-second rolling window.

Pagination Empty: If you pass page=9999 and it exceeds the database bounds, it safely returns [] without throwing a 404 exception.

GET

Retrieve Artists Matrix

GET /?access=api&action=get_artists&api_key=YOUR_ADMIN_KEY

Overview

An extremely advanced aggregation endpoint that crawls the entire SQLite database to extract unique artist strings from embedded ID3 tags. It intelligently executes regex delimiter parsing against strings containing formats like "Daft Punk feat. Pharrell Williams" or "Justice & Kavinsky" to dynamically split them into individual, distinct identities. It then returns a structurally mapped array providing a canonical id pointer, which is crucial for fetching the correct cover art image for that artist via the image endpoint.

Query Parameters

Parameter	Type	Required	Description
`action`	string	Yes	Must be `get_artists`.
`page`	integer	No	Array slice offset. Defaults to `1` (25 items).
`sort`	string	No	Options: `name_asc`, `name_desc`. Defaults to alphabetical `name_asc`.

cURL Request Example

curl -X GET "https://yourdomain.com/?access=api&action=get_artists&api_key=admin&sort=name_asc" \
  -H "Accept: application/json" \
  -H "User-Agent: API-Client/1.0"

Expected JSON Response

[
  {
    "name": "Daft Punk",
    "id": 84,
    "has_img": 1
  },
  {
    "name": "David Bowie",
    "id": 92,
    "has_img": 1
  },
  {
    "name": "Dire Straits",
    "id": 105,
    "has_img": 0
  }
]

Architecture Note: The id field points to the absolute highest integer song ID uploaded by this artist that contains a valid has_img=1 flag in the database. You must append this integer to the get_image endpoint to retrieve the visual artist avatar.

GET

Retrieve Albums Collection

GET /?access=api&action=get_albums&api_key=YOUR_ADMIN_KEY

Overview

Aggregates all music records grouped strictly by the album database field. The server processor automatically scrubs and excludes blank variables or corrupted "Unknown Album" entries to maintain UI integrity. The backend natively computes the song_count length and executes a heavy join to output the total_plays property for the entire album.

Query Parameters

Parameter	Type	Required	Description
`action`	string	Yes	Must be `get_albums`.
`sort`	string	No	Options: `album_asc`, `album_desc`, `year_desc`, `artist_asc`. Defaults to `album_asc`.

Expected JSON Response

[
  {
    "album": "Dark Side of the Moon",
    "artist": "Pink Floyd",
    "user_id": 1,
    "id": 340,
    "year": 1973,
    "song_count": 10,
    "total_plays": 54200
  },
  {
    "album": "Discovery",
    "artist": "Daft Punk",
    "user_id": 2,
    "id": 412,
    "year": 2001,
    "song_count": 14,
    "total_plays": 88030
  }
]

Tip: The id attribute returned here points to the absolute highest song ID associated with this album. Using this ID in the get_image route guarantees you receive the album's unified cover artwork.

GET

Get Genres

GET /?access=api&action=get_genres

Provides a clean, distinct array of all unique string properties recorded inside the genre column across the entire music library table. Highly optimized via GROUP BY COLLATE NOCASE algorithms.

[
  { "name": "Alternative Rock", "id": 55 },
  { "name": "Electronic Dance", "id": 89 }
]

GET

Get Years

GET /?access=api&action=get_years

Groups the database entirely by the numeric year ID3 tag field. Automatically filters out 0 or null integer fallbacks and sorts chronologically descending.

[
  { "name": "2024", "id": 904 },
  { "name": "2023", "id": 822 }
]

GET

Global Aggregated Search

GET /?access=api&action=search&q=QUERY&api_key=YOUR_KEY

Overview

The core intelligence of the library discovery engine. It performs a massive, multi-table cross-referenced LIKE operation against Titles, Artists, Albums, Playlists, and internal Users. Instead of returning a flat array, it structures the response into beautifully nested UI "Shelves", allowing you to render categorical blocks identical to modern streaming platforms immediately upon receipt.

Query Parameters

Parameter	Type	Required	Description
`q`	string	Yes	The URL-encoded search keyword or phrase.
`f_date`	string	No	Time boundary limits. Options: `today`, `week`, `month`, `year`.
`f_dur`	string	No	Length limits. Options: `short` (under 4 mins), `long` (over 20 mins).
`f_sort`	string	No	Advanced sorting matrix. Options: `relevance`, `date`, `views`, `likes`.

Expected JSON Response

{
  "shelves": [
    {
      "title": "Top Result",
      "type": "top_result",
      "items": [
        { "id": 401, "title": "Random Access Memories", "artist": "Daft Punk" }
      ]
    },
    {
      "title": "Artists",
      "type": "artists",
      "items": [
        { "name": "Daft Punk", "id": 401, "is_user": false }
      ]
    },
    {
      "title": "Songs",
      "type": "songs_list",
      "items": [
        { "id": 402, "title": "Get Lucky", "artist": "Daft Punk", "duration": 369 }
      ]
    }
  ]
}

GET

Retrieve Deep Song Metadata

GET /?access=api&action=get_song_data&id=SONG_ID&api_key=YOUR_ADMIN_KEY

Overview

Provides absolute, hyper-detailed JSON structures regarding a singular specific audio track. It exposes system-level technical details including explicitly generated stream_url overrides, internally embedded raw lyrics text blocks (capable of feeding LRC synchronized UI elements), physical file bitrates, ReplayGain offsets, and critically, the per-user custom eq_bands matrix alterations tied to the user_song_settings relationship table.

Expected JSON Response

{
  "id": 1042,
  "file": "/var/www/html/music/uploads/le/led_zeppelin/m_a4b9x.mp3",
  "title": "Stairway to Heaven",
  "artist": "Led Zeppelin",
  "album": "Led Zeppelin IV",
  "genre": "Classic Rock",
  "year": 1971,
  "duration": 482,
  "bitrate": 320000,
  "lyrics": "[00:15.30] There's a lady who's sure...\n[00:22.10] All that glitters is gold...",
  "user_id": 1,
  "is_private": 0,
  "last_modified": 1698765432,
  "replaygain": -4.2,
  "is_favorite": 1,
  "volume_multiplier": 1.2,
  "eq_bands": [2, 0, -1, 3, 5],
  "stream_url": "?action=get_stream&id=1042",
  "image_url": "?action=get_image&id=1042&v=1698765432"
}

GET

Retrieve Playlist Contents

GET /?access=api&action=get_playlist_songs&public_id=PLAYLIST_ID&api_key=YOUR_KEY

Overview

Extracts all song objects associated via the playlist_songs junction table, pointing explicitly to a specific public_id cryptographic token. It enforces extremely tight architectural security rules, outright rejecting query attempts on is_private=1 collections unless directly authenticated by the owner's session token or globally overridden via the api_key.

Query Parameters

Parameter	Type	Required	Description
`public_id`	string	Yes	The 16-character hexadecimal token assigned to the playlist entity.
`sort`	string	No	Order definitions. Options: `manual_order`, `added_newest`, `added_oldest`.
`all`	integer	No	Boolean state `1` or `0`. If 1, it entirely bypasses the 25-item chunking constraints and dumps the entire list array simultaneously.

MEDIA

Stream Audio Data

GET /?action=get_stream&id=SONG_ID

The highest priority internal API route. Operates completely outside the JSON formatter to return heavy binary payloads. Native support for HTTP/1.1 206 Partial Content allows HTML5 <audio> tags to seamlessly transmit Range: bytes= requests, enabling instant timeline scrubbing without transferring gigabytes of unneeded buffer chunks.

Security Override: This route naturally bypasses CORS when instantiated natively via DOM media elements.

MEDIA

Get Cover Art Image

GET /?action=get_image&id=SONG_ID&v=TIMESTAMP

Transmits the ultra-compressed WebP base64 blob embedded in the SQLite music architecture. If no image physically exists in the database for the given ID, the server intercepts the null pointer and dynamically builds an immense SVG vector mathematical graphic bounded to the hexadecimal seed derived from the song's title string!

Performance: The &v= param explicitly fractures strict HTTP caching laws to force UI updates.

MEDIA

Get User Avatar

GET /?action=get_profile_picture&id=USER_ID

Translates the user integer pointer into a image/webp output stream. If the account lacks a custom profile picture, it initiates a complex fallback algorithm: searching the DB for the newest music row uploaded by them that contains cover art, and if that fails, builds an SVG geometric shape.

MEDIA

Download Raw MP3

GET /?action=download_song&id=SONG_ID

Overrides normal streaming directives to enforce a hard physical system download operation. Injects Content-Disposition: attachment headers while intelligently formatting the filename to "Title - Artist.mp3" based securely on the database tags, ignoring the random alphanumeric disk hash.

DATA

Get Explore / Discovery Hub

GET /?access=api&action=get_explore&api_key=YOUR_ADMIN_KEY

Overview

A tremendously heavy computational endpoint containing massive multi-table JOIN subqueries designed to construct randomized algorithm-driven "Shelves" for the Explore tab. It pulls deep track recommendations, aggregates distinct album groupings randomly, parses global play statistics to surface trending records, and identifies prolific artists across the server. Due to execution load, this endpoint automatically serializes its output to a hardware sys_get_temp_dir() cache file governed by a strict 5-minute invalidation clock.

Expected JSON Response

{
  "shelves": [
    {
      "title": "Discover Songs",
      "type": "songs",
      "items": [
        { "id": 401, "title": "Random Access Memories", "artist": "Daft Punk" }, ...
      ]
    },
    {
      "title": "Discover Albums",
      "type": "albums",
      "items": [
        { "album": "Discovery", "artist": "Daft Punk", "id": 84, "song_count": 14 }
      ]
    }
  ]
}

DATA

Get For You AI

GET /?access=api&action=get_recommendations

Identical to the Explore layout engine but intensely localized against the authenticated API Session parameters. Re-calculates mathematical boundaries based exclusively on user history logs, followed relationships, and favorite flags. Requires severe backend processing load.

DATA

Get Play History

GET /?access=api&action=get_history

Targets the history database mapping. Executes a complex grouping schema to safely collapse tracks played multiple times into a singular row driven by a MAX(played_at) ISO string resolver. Appends fully functional UI objects to build timeline interfaces.

DATA

Get User Favorites

GET /?access=api&action=get_favorites

Outputs the array of tracks securely bound to the user's favorites cross-reference table. Enforces a sort_order directional flag to allow for drag-and-drop structural preservation. Core foundation for the internal offline-caching loop capabilities.

DATA

Get Playlists Collections

GET /?access=api&action=get_user_playlists

Aggregates the total array of playlist constructs exclusively tied to the master authentication identifier. Employs heavy aggregation logic to dynamically formulate the internal song_count and the highly complex image_id thumbnail pointing parameter.

POST

Database Mutations (POST Hooks)

These specialized endpoints are explicitly designed to mutate database states securely. They completely ignore URL parameters for data manipulation, strictly demanding rigorous JSON payloads deployed within the body stream. All requests mandate Content-Type: application/json.

POST /?access=api&action=toggle_favorite

JSON Body Schema:

{
  "id": 1042 // The integer ID of the target song
}

Functionality: Scans the favorites binding logic. If the integer ID already exists in the matrix, it physically destroys the row. If absent, it injects a new row calculating the MAX(sort_order) + 1. Responds with the new calculated boolean state {"status":"added", "is_favorite":true}.

POST /?access=api&action=log_play

JSON Body Schema:

{
  "id": 1042, 
  "played_at": "2026-06-28T14:27:00.000Z" // Standard ISO string
}

Functionality: Highly volatile transaction handler. Executes a deep ON CONFLICT DO UPDATE SQL sequence against both the history mapping (to update the chronological timeline) and the play_counts mapping (incrementing the algorithm scalar). It is intensely protected by a looping Retry matrix to mitigate localized SQLite busy-lock scenarios under massive concurrent traffic.

POST /?access=api&action=create_playlist

JSON Body Schema:

{
  "name": "Midnight Drive Array", 
  "is_private": 0 // Integer boolean (0 = Public, 1 = Private)
}

Functionality: Dynamically validates and executes the generation of a new global playlist construct. Generates an exceptionally secure, random 16-character hexadecimal token bound to the public_id column to bypass easily-guessable standard integer indexing methodologies.

Subscribe to this server using any standard RSS reader (Feedly, NetNewsWire, Apple Podcasts, etc.) to stream tracks and receive real-time upload updates.

Feed URL

Open Raw

Recent Feed Entries Loading...

Loading live feed preview...

RSS 2.0 XML Schema

<!-- Fetching XML payload... -->

Home

Table of Contents

Table of Contents

Task Sections

Get Genres

Get Years

Stream Audio Data

Get Cover Art Image

Get User Avatar

Download Raw MP3

Get For You AI

Get Play History

Get User Favorites

Get Playlists Collections

JSON Body Schema:

JSON Body Schema:

JSON Body Schema:

PHPMusic Client

Library Tracks

Home

Application Console

Comprehensive User Guide

The Ultimate Guide

1. Playback & Core Navigation

2. The Advanced Audio Engine

3. Multi-Select Mode

4. Playlists & Organization

5. Offline Library & Caching

6. Community & Interaction

7. Uploading & Deep Metadata

8. Data Portability & Downloads

9. Developer & Power-User Tools

10. Core Icon Dictionary

11. Disclaimers & Fair Use

Keyboard Shortcuts

Playback Controls

Audio & Modes

Interface & Actions

Library Management

Navigation & Quick Access

System Actions

Connections

Reply

Reply to Comment

Reply to Post

Song Comments

Table of Contents

Table of Contents

Task Sections

Formatting Help

Guide

Download

Time & Date

00:00:00

Appeal Account Ban

Appeal Game Suspension

Reset Password

Set New Password

Restore Account

Edit Comment

Edit Post

Edit Post

Edit Blog Comment

Edit Message

Delete Message?

Settings

Profile Picture

Public Profile

Custom Background

Wallpaper Generator

Playback Controls

Audio Processors

5-Band Equalizer

Notifications

Security

Game Ban Status

Data Backup

Danger Zone

Create Group

Group Info

OWNER CONTROLS

Members (0)

Activity Feed

Authentication Required

Account Verification

Upload Permissions Required

Upload Music

Manage Collaborators

All Genres

Manage Song Collaborators

Current Collaborators

Song Collaboration Invite

You've been invited!

Manage Collaborators

Current Collaborators

Collaboration Invite

You've been invited!

Create New Playlist

Edit Playlist