Skip to main content
This guide covers how to load tracks from URLs, search queries, and playlists using DisGoLink.

​
Loading Methods

DisGoLink provides two methods for loading tracks:
  • LoadTracks(): Returns a LoadResult that you handle manually
  • LoadTracksHandler(): Uses a handler interface for cleaner result processing

​
Using LoadTracks()

1

Load from identifier

Load tracks using a URL or search query:
ctx := context.Background()
node := lavalinkClient.BestNode()

// Load from URL
result, err := node.LoadTracks(ctx, "https://www.youtube.com/watch?v=dQw4w9WgXcQ")
if err != nil {
    log.Printf("Failed to load track: %v", err)
    return
}
2

Handle the result

Check the LoadType and handle each case:
switch result.LoadType {
case lavalink.LoadTypeTrack:
    track := result.Data.(lavalink.Track)
    log.Printf("Loaded track: %s", track.Info.Title)

case lavalink.LoadTypePlaylist:
    playlist := result.Data.(lavalink.Playlist)
    log.Printf("Loaded playlist: %s with %d tracks",
        playlist.Info.Name, len(playlist.Tracks))

case lavalink.LoadTypeSearch:
    tracks := result.Data.(lavalink.Search)
    log.Printf("Found %d search results", len(tracks))

case lavalink.LoadTypeEmpty:
    log.Println("No results found")

case lavalink.LoadTypeError:
    exception := result.Data.(lavalink.Exception)
    log.Printf("Load failed: %s", exception.Message)
}

​
Using LoadTracksHandler()

The handler interface provides a cleaner way to handle different result types: 
node.LoadTracksHandler(ctx, identifier, disgolink.NewResultHandler(
    // Track loaded
    func(track lavalink.Track) {
        log.Printf("Loaded: %s", track.Info.Title)
    },
    // Playlist loaded
    func(playlist lavalink.Playlist) {
        log.Printf("Loaded playlist: %s with %d tracks",
            playlist.Info.Name, len(playlist.Tracks))
    },
    // Search results
    func(tracks []lavalink.Track) {
        log.Printf("Found %d results", len(tracks))
        if len(tracks) > 0 {
            log.Printf("First result: %s", tracks[0].Info.Title)
        }
    },
    // No matches
    func() {
        log.Println("No results found")
    },
    // Load failed
    func(err error) {
        log.Printf("Error loading track: %v", err)
    },
))

​
Search Prefixes

Use search prefixes to search on specific platforms: 
identifier := lavalink.SearchTypeYouTube.Apply("never gonna give you up")
// Results in: "ytsearch:never gonna give you up"

result, err := node.LoadTracks(ctx, identifier)

​
Available Search Types

PrefixConstantDescription
ytsearch:SearchTypeYouTubeYouTube search
ytmsearch:SearchTypeYouTubeMusicYouTube Music search
scsearch:SearchTypeSoundCloudSoundCloud search

​
Load Result Types

​
Single Track

Returned when loading a direct track URL: 
result, _ := node.LoadTracks(ctx, "https://youtu.be/dQw4w9WgXcQ")

if result.LoadType == lavalink.LoadTypeTrack {
    track := result.Data.(lavalink.Track)
    
    // Track information
    log.Printf("Title: %s", track.Info.Title)
    log.Printf("Author: %s", track.Info.Author)
    log.Printf("Duration: %s", track.Info.Length)
    log.Printf("URI: %s", *track.Info.URI)
    log.Printf("Source: %s", track.Info.SourceName)
    
    // Encoded track for playback
    encodedTrack := track.Encoded
}

​
Playlist

Returned when loading a playlist URL: 
result, _ := node.LoadTracks(ctx, "https://www.youtube.com/playlist?list=...")

if result.LoadType == lavalink.LoadTypePlaylist {
    playlist := result.Data.(lavalink.Playlist)
    
    // Playlist information
    log.Printf("Name: %s", playlist.Info.Name)
    log.Printf("Selected Track: %d", playlist.Info.SelectedTrack)
    
    // Iterate through tracks
    for i, track := range playlist.Tracks {
        log.Printf("%d. %s - %s", i+1, track.Info.Author, track.Info.Title)
    }
}

​
Search Results

Returned when using search prefixes: 
identifier := lavalink.SearchTypeYouTube.Apply("relaxing music")
result, _ := node.LoadTracks(ctx, identifier)

if result.LoadType == lavalink.LoadTypeSearch {
    tracks := result.Data.(lavalink.Search)
    
    // Search returns a slice of tracks
    if len(tracks) > 0 {
        // Use the first result
        firstTrack := tracks[0]
        log.Printf("Top result: %s", firstTrack.Info.Title)
    }
}

​
Empty Result

Returned when no matches are found: 
result, _ := node.LoadTracks(ctx, "ytsearch:xyzinvalidquery123")

if result.LoadType == lavalink.LoadTypeEmpty {
    log.Println("No tracks found for this query")
}

​
Exception

Returned when an error occurs during loading: 
result, _ := node.LoadTracks(ctx, "invalid-url")

if result.LoadType == lavalink.LoadTypeError {
    exception := result.Data.(lavalink.Exception)
    
    log.Printf("Error: %s", exception.Message)
    log.Printf("Severity: %s", exception.Severity)
    log.Printf("Cause: %s", exception.Cause)
}
Exception Severity Levels:
  • SeverityCommon: Normal errors (e.g., track not found)
  • SeveritySuspicious: Unusual errors that may indicate issues
  • SeverityFault: Serious errors that indicate problems with Lavalink

​
Practical Example

Here’s a complete example handling user input: 
func loadTrack(node disgolink.Node, query string) (*lavalink.Track, error) {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    // Auto-detect URLs vs search queries
    identifier := query
    urlPattern := regexp.MustCompile(`^https?://`)
    if !urlPattern.MatchString(query) {
        // Not a URL, use YouTube search
        identifier = lavalink.SearchTypeYouTube.Apply(query)
    }

    // Load the track
    var track *lavalink.Track
    node.LoadTracksHandler(ctx, identifier, disgolink.NewResultHandler(
        func(t lavalink.Track) {
            track = &t
        },
        func(playlist lavalink.Playlist) {
            if len(playlist.Tracks) > 0 {
                track = &playlist.Tracks[0]
            }
        },
        func(tracks []lavalink.Track) {
            if len(tracks) > 0 {
                track = &tracks[0]
            }
        },
        func() {
            log.Println("No results found")
        },
        func(err error) {
            log.Printf("Load failed: %v", err)
        },
    ))

    if track == nil {
        return nil, fmt.Errorf("no track loaded")
    }

    return track, nil
}

​
Decoding Tracks

If you have an encoded track string (e.g., from a database), you can decode it: 
encodedTrack := "QAAAjQIAJVJpY2sgQXN0bGV5IC0gTmV2ZXIgR29ubmEgR2l2ZSBZb3UgVXA..."

track, err := node.DecodeTrack(ctx, encodedTrack)
if err != nil {
    log.Printf("Failed to decode: %v", err)
    return
}

log.Printf("Decoded track: %s", track.Info.Title)

​
Next Steps

Playing Audio

Learn how to play loaded tracks in voice channels

Error Handling

Handle track loading errors properly

Build docs developers (and LLMs) love

Get started for freeTalk to us