> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.aegi.run/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.aegi.run/_mcp/server.

# Background on a track

GET https://api.aegi.run/v1/music/guilds/{guildId}/meaning

Encyclopedic context and history for a track or artist, aggregated from sources like Wikipedia. Answers with `meaning: null` when nothing was found.

Reference: https://docs.aegi.run/api-reference/aegis/music/background-on-a-track

## Authentication

- `Authorization` header (bearer token, required) — Create a key at [https://aegi.run](https://aegi.run), then send it as `Authorization: Bearer aegis.<key>`.

## Request

### Path parameters

- `guildId` (string, required)

### Query parameters

- `encoded` (string, required) — The `encoded` string from a search result.

## Response

### 200

What was found, if anything.

- `data` (MeaningResult, required)

## Errors

### 403 Forbidden Error

The API key is not linked to a bot.

- `error` (ErrorResponseError, required)
- `requestId` (string, optional)

### 404 Not Found Error

No player in that guild.

- `error` (ErrorResponseError, required)
- `requestId` (string, optional)

### 409 Conflict Error

Conflicts with the current player state.

- `error` (ErrorResponseError, required)
- `requestId` (string, optional)

### 422 Unprocessable Entity Error

The request cannot be carried out as given.

- `error` (ErrorResponseError, required)
- `requestId` (string, optional)

### 503 Service Unavailable Error

The music workers are unavailable or timed out.

- `error` (ErrorResponseError, required)
- `requestId` (string, optional)

## Types

### MeaningResult

- `meaning` (Meaning, required)

### ErrorResponseError

- `code` (enum, required)
  - Allowed values: `bad_request`, `unauthorized`, `invalid_api_key`, `api_key_revoked`, `forbidden`, `player_limit`, `not_found`, `method_not_allowed`, `conflict`, `validation_error`, `rate_limited`, `internal_error`, `service_unavailable`
- `message` (string, required)
- `details` (any, optional, nullable)

### Meaning

- `title` (string, required)
- `description` (string, required)
- `paragraphs` (list of string, required)
- `url` (string, required)
- `provider` (string, required)
- `type` (string, required)

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "data": {
    "meaning": {
      "title": "Never Gonna Give You Up",
      "description": "\"Never Gonna Give You Up\" is a song recorded by English singer and songwriter Rick Astley, released in July 1987 as his debut single.",
      "paragraphs": [
        "\"Never Gonna Give You Up\" is a song recorded by English singer and songwriter Rick Astley. It was released on 27 July 1987 as his debut single and reached number one in 25 countries, including the United Kingdom and the United States.",
        "The song was written and produced by Stock Aitken Waterman. It became one of the best-selling singles of 1987 and has since become a cultural phenomenon, most notably associated with the internet prank known as 'rickrolling'.",
        "In 2021, the music video surpassed one billion views on YouTube, making Astley one of the few artists from the 1980s to achieve this milestone."
      ],
      "url": "https://en.wikipedia.org/wiki/Never_Gonna_Give_You_Up",
      "provider": "wikipedia",
      "type": "track"
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.aegi.run/v1/music/guilds/123456789012345678/meaning"

querystring = {"encoded":"QAAAAAMARFJpY2sgQXN0bGV5..."}

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...';
const options = {
  method: 'GET',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5..."

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("GET", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.aegi.run/v1/music/guilds/123456789012345678/meaning?encoded=QAAAAAMARFJpY2sgQXN0bGV5...")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```