SoundCloud Public API Specification
POST
Likes a playlist.
{{baseUrl}}/likes/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/likes/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/likes/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/likes/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/likes/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/likes/playlists/:playlist_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/likes/playlists/:playlist_id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/likes/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/likes/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/likes/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/likes/playlists/:playlist_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/likes/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/likes/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/likes/playlists/:playlist_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/likes/playlists/:playlist_id',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/likes/playlists/:playlist_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/likes/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/likes/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/likes/playlists/:playlist_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/likes/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/likes/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/likes/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/likes/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/likes/playlists/:playlist_id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/likes/playlists/:playlist_id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/likes/playlists/:playlist_id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/likes/playlists/:playlist_id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("POST", "/baseUrl/likes/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/likes/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/likes/playlists/:playlist_id"
response <- VERB("POST", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/likes/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/likes/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/likes/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/likes/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http POST {{baseUrl}}/likes/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/likes/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/likes/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "200 - OK"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "201 - Created"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 429,
"link": "https://developers.soundcloud.com/docs/api/rate-limits#errors",
"message": "Detailed message of errors, when available",
"spam_warning_urn": "soundcloud:spam-warnings:1"
}
POST
Likes a track.
{{baseUrl}}/likes/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/likes/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/likes/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/likes/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/likes/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/likes/tracks/:track_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/likes/tracks/:track_id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/likes/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/likes/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/likes/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/likes/tracks/:track_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/likes/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/likes/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/likes/tracks/:track_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/likes/tracks/:track_id',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/likes/tracks/:track_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/likes/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/likes/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/likes/tracks/:track_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/likes/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/likes/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/likes/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/likes/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/likes/tracks/:track_id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/likes/tracks/:track_id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/likes/tracks/:track_id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/likes/tracks/:track_id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("POST", "/baseUrl/likes/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/likes/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/likes/tracks/:track_id"
response <- VERB("POST", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/likes/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/likes/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/likes/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/likes/tracks/:track_id \
--header 'authorization: {{apiKey}}'http POST {{baseUrl}}/likes/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/likes/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/likes/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "200 - OK"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 429,
"link": "https://developers.soundcloud.com/docs/api/rate-limits#errors",
"message": "Detailed message of errors, when available",
"spam_warning_urn": "soundcloud:spam-warnings:1"
}
DELETE
Unlikes a playlist.
{{baseUrl}}/likes/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/likes/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/likes/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/likes/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/likes/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/likes/playlists/:playlist_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/likes/playlists/:playlist_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/likes/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/likes/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/likes/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/likes/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/likes/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/likes/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/likes/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/likes/playlists/:playlist_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/likes/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/likes/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/likes/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/likes/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/likes/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/likes/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/likes/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/likes/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/likes/playlists/:playlist_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/likes/playlists/:playlist_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/likes/playlists/:playlist_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/likes/playlists/:playlist_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/likes/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/likes/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/likes/playlists/:playlist_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/likes/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/likes/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/likes/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/likes/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/likes/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/likes/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/likes/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "200 - OK"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Unlikes a track.
{{baseUrl}}/likes/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/likes/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/likes/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/likes/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/likes/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/likes/tracks/:track_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/likes/tracks/:track_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/likes/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/likes/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/likes/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/likes/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/likes/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/likes/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/likes/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/likes/tracks/:track_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/likes/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/likes/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/likes/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/likes/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/likes/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/likes/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/likes/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/likes/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/likes/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/likes/tracks/:track_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/likes/tracks/:track_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/likes/tracks/:track_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/likes/tracks/:track_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/likes/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/likes/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/likes/tracks/:track_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/likes/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/likes/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/likes/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/likes/tracks/:track_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/likes/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/likes/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/likes/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "200 - OK"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Deletes a user who is followed by the authenticated user.
{{baseUrl}}/me/followings/:user_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followings/:user_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/me/followings/:user_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followings/:user_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/me/followings/:user_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followings/:user_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followings/:user_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/me/followings/:user_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/me/followings/:user_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followings/:user_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/me/followings/:user_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/me/followings/:user_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followings/:user_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followings/:user_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/me/followings/:user_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followings/:user_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followings/:user_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followings/:user_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/me/followings/:user_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followings/:user_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followings/:user_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followings/:user_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followings/:user_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/me/followings/:user_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followings/:user_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followings/:user_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followings/:user_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/me/followings/:user_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followings/:user_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/me/followings/:user_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/me/followings/:user_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followings/:user_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followings/:user_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "Status(200) - OK"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 422,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
PUT
Follows a user.
{{baseUrl}}/me/followings/:user_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followings/:user_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/me/followings/:user_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followings/:user_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/me/followings/:user_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followings/:user_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followings/:user_id"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/me/followings/:user_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/me/followings/:user_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followings/:user_id"))
.header("authorization", "{{apiKey}}")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.put(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/me/followings/:user_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/me/followings/:user_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'PUT', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followings/:user_id',
method: 'PUT',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.put(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followings/:user_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/me/followings/:user_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'PUT', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followings/:user_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followings/:user_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followings/:user_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/me/followings/:user_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followings/:user_id');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followings/:user_id');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followings/:user_id' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followings/:user_id' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("PUT", "/baseUrl/me/followings/:user_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followings/:user_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followings/:user_id"
response <- VERB("PUT", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followings/:user_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/me/followings/:user_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followings/:user_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/me/followings/:user_id \
--header 'authorization: {{apiKey}}'http PUT {{baseUrl}}/me/followings/:user_id \
authorization:'{{apiKey}}'wget --quiet \
--method PUT \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followings/:user_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followings/:user_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"status": "200 - Successful"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Recent the authenticated user's activities.
{{baseUrl}}/me/activities/all/own
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/activities/all/own");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/activities/all/own" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/activities/all/own"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/activities/all/own"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/activities/all/own");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/activities/all/own"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/activities/all/own HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/activities/all/own")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/activities/all/own"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/activities/all/own")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/activities/all/own")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/activities/all/own');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/all/own',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/activities/all/own';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/activities/all/own',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/activities/all/own")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/activities/all/own',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/all/own',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/activities/all/own');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/all/own',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/activities/all/own';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/activities/all/own"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/activities/all/own" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/activities/all/own",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/activities/all/own', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/activities/all/own');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/activities/all/own');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/activities/all/own' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/activities/all/own' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/activities/all/own", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/activities/all/own"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/activities/all/own"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/activities/all/own")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/activities/all/own') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/activities/all/own";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/activities/all/own \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/activities/all/own \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/activities/all/ownimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/activities/all/own")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": [
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}
]
},
"type": "track:repost"
},
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}
]
},
"type": "playlist"
}
],
"future_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=000001",
"next_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=00000"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of favorited or liked tracks of the authenticated user.
{{baseUrl}}/me/likes/tracks
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/likes/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/likes/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/likes/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/likes/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/likes/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/likes/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/likes/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/likes/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/likes/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/likes/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/likes/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/likes/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/likes/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/likes/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/likes/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/likes/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/likes/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/likes/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/likes/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/likes/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/likes/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/likes/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/likes/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/likes/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/likes/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/likes/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/likes/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/likes/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/likes/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/likes/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/likes/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/likes/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/likes/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/likes/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/likes/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/likes/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of recent tracks from users followed by the authenticated user.
{{baseUrl}}/me/followings/tracks
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followings/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/followings/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followings/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/followings/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followings/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followings/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/followings/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/followings/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followings/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followings/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/followings/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/followings/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followings/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followings/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followings/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followings/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/followings/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followings/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followings/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followings/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followings/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/followings/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followings/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followings/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followings/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followings/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/followings/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followings/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followings/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followings/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/followings/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followings/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/followings/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/followings/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followings/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followings/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of the authenticated user's connected social accounts.
{{baseUrl}}/me/connections
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/connections");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/connections" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/connections"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/connections"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/connections");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/connections"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/connections HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/connections")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/connections"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/connections")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/connections")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/connections');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/connections';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/connections',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/connections")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/connections',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/connections');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/connections';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/connections"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/connections" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/connections",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/connections', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/connections');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/connections');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/connections' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/connections' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/connections", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/connections"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/connections"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/connections")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/connections') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/connections";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/connections \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/connections \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/connectionsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/connections")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"created_at": "1995/07/24 08:55:02 +0000",
"display_name": "Full Name",
"id": 123456,
"kind": "connection",
"post_favorite": true,
"post_publish": true,
"service": "google_plus",
"type": "google_plus",
"uri": "https://api.soundcloud.com/connections/123456"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's tracks.
{{baseUrl}}/me/tracks
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of users who are followed by the authenticated user.
{{baseUrl}}/me/followings
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/followings" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followings"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/followings"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followings");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followings"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/followings HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/followings")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followings"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followings")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/followings")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/followings');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followings';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followings',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followings")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followings',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/followings');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followings';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followings" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/followings', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followings');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followings');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followings' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followings' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/followings", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followings"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followings"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/followings') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/followings \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/followings \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followingsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of users who are following the authenticated user.
{{baseUrl}}/me/followers
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followers");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/followers" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followers"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/followers"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followers");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followers"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/followers HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/followers")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followers"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followers")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/followers")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/followers');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followers';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followers',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followers")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followers',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/followers');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followers';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followers"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followers" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followers",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/followers', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followers');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followers');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followers' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followers' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/followers", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followers"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followers"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/followers') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followers";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/followers \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/followers \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followersimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followers")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a specified track. (use -tracks-{track_id} instead, to fetch the track details)
{{baseUrl}}/me/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/tracks/:track_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/tracks/:track_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/tracks/:track_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/tracks/:track_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/tracks/:track_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/tracks/:track_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/tracks/:track_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/tracks/:track_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/tracks/:track_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/tracks/:track_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/tracks/:track_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/tracks/:track_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/tracks/:track_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}
GET
Returns a user who is followed by the authenticated user. (use -users-{user_id} instead, to fetch the user details)
{{baseUrl}}/me/followings/:user_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followings/:user_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/followings/:user_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followings/:user_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/followings/:user_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followings/:user_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followings/:user_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/followings/:user_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/followings/:user_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followings/:user_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/followings/:user_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/followings/:user_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followings/:user_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followings/:user_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followings/:user_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/followings/:user_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followings/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followings/:user_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followings/:user_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followings/:user_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followings/:user_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/followings/:user_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followings/:user_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followings/:user_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followings/:user_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followings/:user_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/followings/:user_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followings/:user_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followings/:user_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followings/:user_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/followings/:user_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followings/:user_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/followings/:user_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/followings/:user_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followings/:user_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followings/:user_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a user who is following the authenticated user. (use -users-{user_id} instead, to fetch the user details)
{{baseUrl}}/me/followers/:follower_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
follower_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/followers/:follower_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/followers/:follower_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/followers/:follower_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/followers/:follower_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/followers/:follower_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/followers/:follower_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/followers/:follower_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/followers/:follower_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/followers/:follower_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/followers/:follower_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/followers/:follower_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/followers/:follower_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers/:follower_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/followers/:follower_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/followers/:follower_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/followers/:follower_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/followers/:follower_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers/:follower_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/followers/:follower_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/followers/:follower_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/followers/:follower_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/followers/:follower_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/followers/:follower_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/followers/:follower_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/followers/:follower_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/followers/:follower_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/followers/:follower_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/followers/:follower_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/followers/:follower_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/followers/:follower_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/followers/:follower_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/followers/:follower_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/followers/:follower_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/followers/:follower_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/followers/:follower_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/followers/:follower_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/followers/:follower_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/followers/:follower_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/followers/:follower_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns playlist. (use -playlists-{playlist_id} instead, to fetch the playlist details)
{{baseUrl}}/me/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/playlists/:playlist_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/playlists/:playlist_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/playlists/:playlist_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/playlists/:playlist_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/playlists/:playlist_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/playlists/:playlist_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/playlists/:playlist_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/playlists/:playlist_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/playlists/:playlist_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/playlists/:playlist_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/playlists/:playlist_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/playlists/:playlist_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}
GET
Returns the authenticated user's activities.
{{baseUrl}}/me/activities
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/activities");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/activities" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/activities"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/activities"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/activities");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/activities"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/activities HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/activities")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/activities"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/activities")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/activities")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/activities');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/activities';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/activities',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/activities")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/activities',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/activities');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/activities';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/activities"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/activities" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/activities",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/activities', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/activities');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/activities');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/activities' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/activities' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/activities", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/activities"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/activities"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/activities")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/activities') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/activities";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/activities \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/activities \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/activitiesimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/activities")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": [
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}
]
},
"type": "track:repost"
},
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}
]
},
"type": "playlist"
}
],
"future_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=000001",
"next_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=00000"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns the authenticated user's connected social account.
{{baseUrl}}/me/connections/:connection_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
connection_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/connections/:connection_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/connections/:connection_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/connections/:connection_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/connections/:connection_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/connections/:connection_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/connections/:connection_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/connections/:connection_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/connections/:connection_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/connections/:connection_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/connections/:connection_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/connections/:connection_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/connections/:connection_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections/:connection_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/connections/:connection_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/connections/:connection_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/connections/:connection_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/connections/:connection_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections/:connection_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/connections/:connection_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/connections/:connection_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/connections/:connection_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/connections/:connection_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/connections/:connection_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/connections/:connection_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/connections/:connection_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/connections/:connection_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/connections/:connection_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/connections/:connection_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/connections/:connection_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/connections/:connection_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/connections/:connection_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/connections/:connection_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/connections/:connection_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/connections/:connection_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/connections/:connection_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/connections/:connection_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/connections/:connection_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/connections/:connection_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/connections/:connection_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"created_at": "1995/07/24 08:55:02 +0000",
"display_name": "Full Name",
"id": 123456,
"kind": "connection",
"post_favorite": true,
"post_publish": true,
"service": "google_plus",
"type": "google_plus",
"uri": "https://api.soundcloud.com/connections/123456"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/activities/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/activities/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/activities/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/activities/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/activities/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/activities/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/activities/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/activities/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/activities/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/activities/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/activities/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/activities/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/activities/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/activities/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/activities/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/activities/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/activities/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/activities/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/activities/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/activities/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/activities/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/activities/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/activities/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/activities/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/activities/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/activities/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/activities/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/activities/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/activities/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/activities/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/activities/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/activities/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/activities/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/activities/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/activities/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/activities/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/activities/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": [
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}
]
},
"type": "track:repost"
},
{
"created_at": "2020/10/12 12:02:44 +0000",
"origin": {
"allOf": [
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}
]
},
"type": "playlist"
}
],
"future_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=000001",
"next_href": "https://api.soundcloud.com/me/activities?limit=10&cursor=00000"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns the authenticated user’s information.
{{baseUrl}}/me
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/meimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"locale": "en",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"primary_email_confirmed": true,
"private_playlists_count": 0,
"private_tracks_count": 0,
"public_favorites_count": 20,
"quota": {
"unlimited_upload_quota": false,
"upload_seconds_left": 10800,
"upload_seconds_used": 0
},
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns user’s favorites ids. (use -me-likes-tracks instead to fetch the authenticated user's likes)
{{baseUrl}}/me/favorites/ids
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/favorites/ids");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/favorites/ids" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/favorites/ids"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/favorites/ids"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/favorites/ids");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/favorites/ids"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/favorites/ids HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/favorites/ids")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/favorites/ids"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/favorites/ids")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/favorites/ids")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/favorites/ids');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/favorites/ids',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/favorites/ids';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/favorites/ids',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/favorites/ids")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/favorites/ids',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/favorites/ids',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/favorites/ids');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/favorites/ids',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/favorites/ids';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/favorites/ids"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/favorites/ids" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/favorites/ids",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/favorites/ids', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/favorites/ids');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/favorites/ids');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/favorites/ids' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/favorites/ids' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/favorites/ids", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/favorites/ids"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/favorites/ids"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/favorites/ids")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/favorites/ids') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/favorites/ids";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/favorites/ids \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/favorites/ids \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/favorites/idsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/favorites/ids")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()
GET
Returns user’s playlists (sets).
{{baseUrl}}/me/playlists
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/me/playlists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/me/playlists" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/me/playlists"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/me/playlists"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/me/playlists");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/me/playlists"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/me/playlists HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/me/playlists")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/me/playlists"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/me/playlists")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/me/playlists")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/me/playlists');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/me/playlists';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/me/playlists',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/me/playlists")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/me/playlists',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/me/playlists');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/me/playlists',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/me/playlists';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/me/playlists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/me/playlists" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/me/playlists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/me/playlists', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/me/playlists');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/me/playlists');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/me/playlists' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/me/playlists' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/me/playlists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/me/playlists"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/me/playlists"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/me/playlists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/me/playlists') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/me/playlists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/me/playlists \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/me/playlists \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/me/playlistsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/me/playlists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Resolves soundcloud.com URLs to Resource URLs to use with the API.
{{baseUrl}}/resolve
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
url
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resolve?url=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/resolve" {:headers {:authorization "{{apiKey}}"}
:query-params {:url ""}})require "http/client"
url = "{{baseUrl}}/resolve?url="
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/resolve?url="),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/resolve?url=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/resolve?url="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/resolve?url= HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resolve?url=")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/resolve?url="))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/resolve?url=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/resolve?url=")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/resolve?url=');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/resolve',
params: {url: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/resolve?url=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/resolve?url=',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/resolve?url=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/resolve?url=',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/resolve',
qs: {url: ''},
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/resolve');
req.query({
url: ''
});
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/resolve',
params: {url: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/resolve?url=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resolve?url="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/resolve?url=" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/resolve?url=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/resolve?url=', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/resolve');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'url' => ''
]);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/resolve');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'url' => ''
]));
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resolve?url=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resolve?url=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/resolve?url=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/resolve"
querystring = {"url":""}
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/resolve"
queryString <- list(url = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/resolve?url=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/resolve') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.params['url'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/resolve";
let querystring = [
("url", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/resolve?url=' \
--header 'authorization: {{apiKey}}'http GET '{{baseUrl}}/resolve?url=' \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- '{{baseUrl}}/resolve?url='import Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resolve?url=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()
GET
The OAuth2 authorization endpoint. Your app redirects a user to this endpoint, allowing them to delegate access to their account.
{{baseUrl}}/connect
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
client_id
redirect_uri
response_type
scope
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/connect" {:headers {:authorization "{{apiKey}}"}
:query-params {:client_id ""
:redirect_uri ""
:response_type ""
:scope ""}})require "http/client"
url = "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope="
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope="),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/connect?client_id=&redirect_uri=&response_type=&scope= HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope="))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/connect',
params: {client_id: '', redirect_uri: '', response_type: '', scope: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/connect?client_id=&redirect_uri=&response_type=&scope=',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/connect',
qs: {client_id: '', redirect_uri: '', response_type: '', scope: ''},
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/connect');
req.query({
client_id: '',
redirect_uri: '',
response_type: '',
scope: ''
});
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/connect',
params: {client_id: '', redirect_uri: '', response_type: '', scope: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/connect');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '',
'redirect_uri' => '',
'response_type' => '',
'scope' => ''
]);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/connect');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '',
'redirect_uri' => '',
'response_type' => '',
'scope' => ''
]));
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/connect?client_id=&redirect_uri=&response_type=&scope=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/connect"
querystring = {"client_id":"","redirect_uri":"","response_type":"","scope":""}
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/connect"
queryString <- list(
client_id = "",
redirect_uri = "",
response_type = "",
scope = ""
)
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/connect') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.params['client_id'] = ''
req.params['redirect_uri'] = ''
req.params['response_type'] = ''
req.params['scope'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/connect";
let querystring = [
("client_id", ""),
("redirect_uri", ""),
("response_type", ""),
("scope", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=' \
--header 'authorization: {{apiKey}}'http GET '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=' \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- '{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope='import Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect?client_id=&redirect_uri=&response_type=&scope=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
This endpoint accepts POST requests and is used to provision access tokens once a user has authorized your application.
{{baseUrl}}/oauth2/token
QUERY PARAMS
client_id
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/oauth2/token" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/oauth2/token?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/oauth2/token',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/oauth2/token?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/oauth2/token',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/oauth2/token');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/oauth2/token',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/oauth2/token');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/oauth2/token');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
payload = ""
conn.request("POST", "/baseUrl/oauth2/token?client_id=%7B%7BapiKey%7D%7D", payload)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/oauth2/token"
querystring = {"client_id":"{{apiKey}}"}
payload = ""
response = requests.post(url, data=payload, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/oauth2/token"
queryString <- list(client_id = "{{apiKey}}")
payload <- ""
response <- VERB("POST", url, body = payload, query = queryString, content_type(""))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/oauth2/token') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/oauth2/token";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D'http POST '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method POST \
--output-document \
- '{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/oauth2/token?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access_token": "some string",
"expires_in": 21599,
"refresh_token": "some string",
"scope": ""
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access_token": "some string",
"scope": "non-expiring"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/guide#authentication",
"message": "invalid_grant"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/guide#authentication",
"message": "unsupported_grant"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
Creates a playlist.
{{baseUrl}}/playlists
HEADERS
Authorization
{{apiKey}}
BODY json
{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/playlists" {:headers {:authorization "{{apiKey}}"}
:content-type :json
:form-params {:playlist {:description ""
:sharing ""
:title ""
:tracks [{:id ""}]}}})require "http/client"
url = "{{baseUrl}}/playlists"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
"content-type" => "application/json"
}
reqBody = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/playlists"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
Content = new StringContent("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists"
payload := strings.NewReader("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("authorization", "{{apiKey}}")
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))
}POST /baseUrl/playlists HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 137
{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/playlists")
.setHeader("authorization", "{{apiKey}}")
.setHeader("content-type", "application/json")
.setBody("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists"))
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists")
.post(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/playlists")
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.body("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
.asString(); const data = JSON.stringify({
playlist: {
description: '',
sharing: '',
title: '',
tracks: [
{
id: ''
}
]
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/playlists');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/playlists',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists';
const options = {
method: 'POST',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"playlist":{"description":"","sharing":"","title":"","tracks":[{"id":""}]}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists',
method: 'POST',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
},
processData: false,
data: '{\n "playlist": {\n "description": "",\n "sharing": "",\n "title": "",\n "tracks": [\n {\n "id": ""\n }\n ]\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/playlists")
.post(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/playlists',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/playlists');
req.headers({
authorization: '{{apiKey}}',
'content-type': 'application/json'
});
req.type('json');
req.send({
playlist: {
description: '',
sharing: '',
title: '',
tracks: [
{
id: ''
}
]
}
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/playlists',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists';
const options = {
method: 'POST',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"playlist":{"description":"","sharing":"","title":"","tracks":[{"id":""}]}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"playlist": @{ @"description": @"", @"sharing": @"", @"title": @"", @"tracks": @[ @{ @"id": @"" } ] } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists" in
let headers = Header.add_list (Header.init ()) [
("authorization", "{{apiKey}}");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]),
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/playlists', [
'body' => '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}',
'headers' => [
'authorization' => '{{apiKey}}',
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]));
$request->setRequestUrl('{{baseUrl}}/playlists');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
headers = {
'authorization': "{{apiKey}}",
'content-type': "application/json"
}
conn.request("POST", "/baseUrl/playlists", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists"
payload = { "playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [{ "id": "" }]
} }
headers = {
"authorization": "{{apiKey}}",
"content-type": "application/json"
}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists"
payload <- "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/playlists') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.body = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists";
let payload = json!({"playlist": json!({
"description": "",
"sharing": "",
"title": "",
"tracks": (json!({"id": ""}))
})});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/playlists \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--data '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'echo '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}' | \
http POST {{baseUrl}}/playlists \
authorization:'{{apiKey}}' \
content-type:application/jsonwget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--body-data '{\n "playlist": {\n "description": "",\n "sharing": "",\n "title": "",\n "tracks": [\n {\n "id": ""\n }\n ]\n }\n}' \
--output-document \
- {{baseUrl}}/playlistsimport Foundation
let headers = [
"authorization": "{{apiKey}}",
"content-type": "application/json"
]
let parameters = ["playlist": [
"description": "",
"sharing": "",
"title": "",
"tracks": [["id": ""]]
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Deletes a playlist.
{{baseUrl}}/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists/:playlist_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists/:playlist_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists/:playlist_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:playlist_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:playlist_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists/:playlist_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a collection of playlist's reposters.
{{baseUrl}}/playlists/:playlist_id/reposters
QUERY PARAMS
client_id
{{apiKey}}
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/playlists/:playlist_id/reposters" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/reposters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/reposters',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/playlists/:playlist_id/reposters');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/reposters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/playlists/:playlist_id/reposters');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/playlists/:playlist_id/reposters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists/:playlist_id/reposters"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists/:playlist_id/reposters"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/playlists/:playlist_id/reposters') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists/:playlist_id/reposters";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:playlist_id/reposters?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a playlist.
{{baseUrl}}/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists/:playlist_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists/:playlist_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists/:playlist_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:playlist_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:playlist_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists/:playlist_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns tracks under a playlist.
{{baseUrl}}/playlists/:playlist_id/tracks
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:playlist_id/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/playlists/:playlist_id/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/playlists/:playlist_id/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/playlists/:playlist_id/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists/:playlist_id/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists/:playlist_id/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/playlists/:playlist_id/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists/:playlist_id/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists/:playlist_id/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/playlists/:playlist_id/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/playlists/:playlist_id/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists/:playlist_id/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists/:playlist_id/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists/:playlist_id/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/playlists/:playlist_id/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists/:playlist_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists/:playlist_id/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:playlist_id/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists/:playlist_id/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists/:playlist_id/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/playlists/:playlist_id/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists/:playlist_id/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/playlists/:playlist_id/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:playlist_id/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:playlist_id/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/playlists/:playlist_id/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists/:playlist_id/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists/:playlist_id/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists/:playlist_id/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/playlists/:playlist_id/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists/:playlist_id/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/playlists/:playlist_id/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/playlists/:playlist_id/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/playlists/:playlist_id/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:playlist_id/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
PUT
Updates a playlist.
{{baseUrl}}/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
BODY json
{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}
:content-type :json
:form-params {:playlist {:description ""
:sharing ""
:title ""
:tracks [{:id ""}]}}})require "http/client"
url = "{{baseUrl}}/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
"content-type" => "application/json"
}
reqBody = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
Content = new StringContent("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists/:playlist_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists/:playlist_id"
payload := strings.NewReader("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("authorization", "{{apiKey}}")
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))
}PUT /baseUrl/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 137
{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.setHeader("content-type", "application/json")
.setBody("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.put(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.body("{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
.asString(); const data = JSON.stringify({
playlist: {
description: '',
sharing: '',
title: '',
tracks: [
{
id: ''
}
]
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {
method: 'PUT',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"playlist":{"description":"","sharing":"","title":"","tracks":[{"id":""}]}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists/:playlist_id',
method: 'PUT',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
},
processData: false,
data: '{\n "playlist": {\n "description": "",\n "sharing": "",\n "title": "",\n "tracks": [\n {\n "id": ""\n }\n ]\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/playlists/:playlist_id")
.put(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}',
'content-type': 'application/json'
});
req.type('json');
req.send({
playlist: {
description: '',
sharing: '',
title: '',
tracks: [
{
id: ''
}
]
}
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {playlist: {description: '', sharing: '', title: '', tracks: [{id: ''}]}}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists/:playlist_id';
const options = {
method: 'PUT',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"playlist":{"description":"","sharing":"","title":"","tracks":[{"id":""}]}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"playlist": @{ @"description": @"", @"sharing": @"", @"title": @"", @"tracks": @[ @{ @"id": @"" } ] } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists/:playlist_id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "{{apiKey}}");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]),
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/playlists/:playlist_id', [
'body' => '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}',
'headers' => [
'authorization' => '{{apiKey}}',
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'playlist' => [
'description' => '',
'sharing' => '',
'title' => '',
'tracks' => [
[
'id' => ''
]
]
]
]));
$request->setRequestUrl('{{baseUrl}}/playlists/:playlist_id');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:playlist_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:playlist_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
headers = {
'authorization': "{{apiKey}}",
'content-type': "application/json"
}
conn.request("PUT", "/baseUrl/playlists/:playlist_id", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists/:playlist_id"
payload = { "playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [{ "id": "" }]
} }
headers = {
"authorization": "{{apiKey}}",
"content-type": "application/json"
}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists/:playlist_id"
payload <- "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.body = "{\n \"playlist\": {\n \"description\": \"\",\n \"sharing\": \"\",\n \"title\": \"\",\n \"tracks\": [\n {\n \"id\": \"\"\n }\n ]\n }\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists/:playlist_id";
let payload = json!({"playlist": json!({
"description": "",
"sharing": "",
"title": "",
"tracks": (json!({"id": ""}))
})});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/playlists/:playlist_id \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--data '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}'echo '{
"playlist": {
"description": "",
"sharing": "",
"title": "",
"tracks": [
{
"id": ""
}
]
}
}' | \
http PUT {{baseUrl}}/playlists/:playlist_id \
authorization:'{{apiKey}}' \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--body-data '{\n "playlist": {\n "description": "",\n "sharing": "",\n "title": "",\n "tracks": [\n {\n "id": ""\n }\n ]\n }\n}' \
--output-document \
- {{baseUrl}}/playlists/:playlist_idimport Foundation
let headers = [
"authorization": "{{apiKey}}",
"content-type": "application/json"
]
let parameters = ["playlist": [
"description": "",
"sharing": "",
"title": "",
"tracks": [["id": ""]]
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Removes a repost on a playlist as the authenticated user
{{baseUrl}}/reposts/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reposts/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/reposts/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/reposts/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/reposts/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/reposts/playlists/:playlist_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/reposts/playlists/:playlist_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/reposts/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/reposts/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/reposts/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/reposts/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/reposts/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/reposts/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/reposts/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/reposts/playlists/:playlist_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/reposts/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/reposts/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/reposts/playlists/:playlist_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reposts/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/reposts/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/reposts/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/reposts/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/reposts/playlists/:playlist_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/reposts/playlists/:playlist_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reposts/playlists/:playlist_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reposts/playlists/:playlist_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/reposts/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/reposts/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/reposts/playlists/:playlist_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/reposts/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/reposts/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/reposts/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/reposts/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/reposts/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/reposts/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reposts/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Removes a repost on a track as the authenticated user
{{baseUrl}}/reposts/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reposts/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/reposts/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/reposts/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/reposts/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/reposts/tracks/:track_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/reposts/tracks/:track_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/reposts/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/reposts/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/reposts/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/reposts/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/reposts/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/reposts/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/reposts/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/reposts/tracks/:track_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/reposts/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/reposts/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/reposts/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/reposts/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reposts/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/reposts/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/reposts/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/reposts/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/reposts/tracks/:track_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/reposts/tracks/:track_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reposts/tracks/:track_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reposts/tracks/:track_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/reposts/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/reposts/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/reposts/tracks/:track_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/reposts/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/reposts/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/reposts/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/reposts/tracks/:track_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/reposts/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/reposts/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reposts/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
Reposts a playlist as the authenticated user
{{baseUrl}}/reposts/playlists/:playlist_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
playlist_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reposts/playlists/:playlist_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/reposts/playlists/:playlist_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/reposts/playlists/:playlist_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/reposts/playlists/:playlist_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/reposts/playlists/:playlist_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/reposts/playlists/:playlist_id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/reposts/playlists/:playlist_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/reposts/playlists/:playlist_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/reposts/playlists/:playlist_id"))
.header("authorization", "{{apiKey}}")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/reposts/playlists/:playlist_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/reposts/playlists/:playlist_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/reposts/playlists/:playlist_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/reposts/playlists/:playlist_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/reposts/playlists/:playlist_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/reposts/playlists/:playlist_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/reposts/playlists/:playlist_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/playlists/:playlist_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/reposts/playlists/:playlist_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reposts/playlists/:playlist_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/reposts/playlists/:playlist_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/reposts/playlists/:playlist_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/reposts/playlists/:playlist_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/reposts/playlists/:playlist_id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/reposts/playlists/:playlist_id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reposts/playlists/:playlist_id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reposts/playlists/:playlist_id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("POST", "/baseUrl/reposts/playlists/:playlist_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/reposts/playlists/:playlist_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/reposts/playlists/:playlist_id"
response <- VERB("POST", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/reposts/playlists/:playlist_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/reposts/playlists/:playlist_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/reposts/playlists/:playlist_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/reposts/playlists/:playlist_id \
--header 'authorization: {{apiKey}}'http POST {{baseUrl}}/reposts/playlists/:playlist_id \
authorization:'{{apiKey}}'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/reposts/playlists/:playlist_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reposts/playlists/:playlist_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
Reposts a track as the authenticated user
{{baseUrl}}/reposts/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/reposts/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/reposts/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/reposts/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/reposts/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/reposts/tracks/:track_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/reposts/tracks/:track_id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/reposts/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/reposts/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/reposts/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/reposts/tracks/:track_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/reposts/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/reposts/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/reposts/tracks/:track_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/reposts/tracks/:track_id',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/reposts/tracks/:track_id")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/reposts/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/reposts/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/reposts/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/reposts/tracks/:track_id';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/reposts/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/reposts/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/reposts/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/reposts/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/reposts/tracks/:track_id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/reposts/tracks/:track_id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/reposts/tracks/:track_id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/reposts/tracks/:track_id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("POST", "/baseUrl/reposts/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/reposts/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/reposts/tracks/:track_id"
response <- VERB("POST", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/reposts/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/reposts/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/reposts/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/reposts/tracks/:track_id \
--header 'authorization: {{apiKey}}'http POST {{baseUrl}}/reposts/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/reposts/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/reposts/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Performs a playlist search based on a query
{{baseUrl}}/playlists
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
q
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists?q=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/playlists" {:headers {:authorization "{{apiKey}}"}
:query-params {:q ""}})require "http/client"
url = "{{baseUrl}}/playlists?q="
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/playlists?q="),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/playlists?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/playlists?q="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/playlists?q= HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists?q=")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/playlists?q="))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/playlists?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/playlists?q=")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/playlists?q=');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/playlists?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/playlists?q=',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/playlists?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/playlists?q=',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists',
qs: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/playlists');
req.query({
q: ''
});
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/playlists',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/playlists?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists?q="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/playlists?q=" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/playlists?q=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/playlists?q=', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/playlists');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'q' => ''
]);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/playlists');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'q' => ''
]));
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists?q=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists?q=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/playlists?q=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/playlists"
querystring = {"q":""}
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/playlists"
queryString <- list(q = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/playlists?q=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/playlists') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.params['q'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/playlists";
let querystring = [
("q", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/playlists?q=' \
--header 'authorization: {{apiKey}}'http GET '{{baseUrl}}/playlists?q=' \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- '{{baseUrl}}/playlists?q='import Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists?q=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Performs a track search based on a query
{{baseUrl}}/tracks
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
q
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks?q=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks" {:headers {:authorization "{{apiKey}}"}
:query-params {:q ""}})require "http/client"
url = "{{baseUrl}}/tracks?q="
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks?q="),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks?q="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks?q= HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks?q=")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks?q="))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks?q=")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks?q=');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks?q=',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks?q=',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks',
qs: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks');
req.query({
q: ''
});
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks?q="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks?q=" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks?q=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks?q=', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'q' => ''
]);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'q' => ''
]));
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks?q=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks?q=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/tracks?q=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks"
querystring = {"q":""}
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks"
queryString <- list(q = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks?q=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.params['q'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks";
let querystring = [
("q", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks?q=' \
--header 'authorization: {{apiKey}}'http GET '{{baseUrl}}/tracks?q=' \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- '{{baseUrl}}/tracks?q='import Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks?q=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Performs a user search based on a query
{{baseUrl}}/users
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
q
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users?q=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users" {:headers {:authorization "{{apiKey}}"}
:query-params {:q ""}})require "http/client"
url = "{{baseUrl}}/users?q="
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users?q="),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users?q="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users?q= HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users?q=")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users?q="))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users?q=")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users?q=');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users?q=',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users?q=")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users?q=',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users',
qs: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users');
req.query({
q: ''
});
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users',
params: {q: ''},
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users?q=';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users?q="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users?q=" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users?q=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users?q=', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'q' => ''
]);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'q' => ''
]));
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users?q=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users?q=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users?q=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users"
querystring = {"q":""}
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/users"
queryString <- list(q = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users?q=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.params['q'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users";
let querystring = [
("q", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/users?q=' \
--header 'authorization: {{apiKey}}'http GET '{{baseUrl}}/users?q=' \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- '{{baseUrl}}/users?q='import Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users?q=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
DELETE
Deletes a track.
{{baseUrl}}/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id',
method: 'DELETE',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id")
.delete(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/tracks/:track_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("DELETE", "/baseUrl/tracks/:track_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id"
response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/tracks/:track_id \
--header 'authorization: {{apiKey}}'http DELETE {{baseUrl}}/tracks/:track_id \
authorization:'{{apiKey}}'wget --quiet \
--method DELETE \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/tracks/:track_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a collection of track's reposters.
{{baseUrl}}/tracks/:track_id/reposters
QUERY PARAMS
client_id
{{apiKey}}
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id/reposters" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/reposters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/reposters',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id/reposters');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/reposters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/reposters');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/reposters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/reposters"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/reposters"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id/reposters') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/reposters";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/reposters?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of users who have favorited or liked the track.
{{baseUrl}}/tracks/:track_id/favoriters
QUERY PARAMS
client_id
{{apiKey}}
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id/favoriters" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/favoriters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/favoriters',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id/favoriters');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/favoriters',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/favoriters');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/favoriters');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/favoriters"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/favoriters"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id/favoriters') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/favoriters";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/favoriters?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a track's streamable URLs
{{baseUrl}}/tracks/:track_id/streams
QUERY PARAMS
client_id
{{apiKey}}
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id/streams" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/streams',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/streams',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id/streams');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/streams',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/streams');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/streams');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/streams"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/streams"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id/streams') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/streams";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/streams?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"hls_mp3_128_url": "https://cf-media.sndcdn.com/",
"hls_opus_64_url": "https://cf-media.sndcdn.com/",
"http_mp3_128_url": "https://cf-media.sndcdn.com/",
"preview_mp3_128_url": "https://cf-media.sndcdn.com/"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a track.
{{baseUrl}}/tracks/:track_id
QUERY PARAMS
client_id
{{apiKey}}
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id/related" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/related',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/related',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id/related');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/related',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/related');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/related');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/related"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/related"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id/related') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/related";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/related?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns the comments posted on the track(track_id).
{{baseUrl}}/tracks/:track_id/comments
QUERY PARAMS
client_id
{{apiKey}}
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tracks/:track_id/comments" {:query-params {:client_id "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/comments',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/comments',
qs: {client_id: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tracks/:track_id/comments');
req.query({
client_id: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/tracks/:track_id/comments',
params: {client_id: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D');
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/comments');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'client_id' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/comments');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'client_id' => '{{apiKey}}'
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/comments"
querystring = {"client_id":"{{apiKey}}"}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/comments"
queryString <- list(client_id = "{{apiKey}}")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tracks/:track_id/comments') do |req|
req.params['client_id'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/comments";
let querystring = [
("client_id", "{{apiKey}}"),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D'http GET '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D'wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D'import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/comments?client_id=%7B%7BapiKey%7D%7D")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"body": "comment body",
"created_at": "2007/09/11 15:40:24 +0000",
"id": 1234,
"kind": "comment",
"timestamp": 4960,
"track_id": 123456,
"uri": "https://api.soundcloud.com/comments/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"followers_count": 138,
"followings_count": 172,
"id": 12345,
"kind": "user",
"last_modified": "2017/04/10 14:48:03 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"public_favorites_count": 5,
"reposts_count": 0,
"uri": "https://api.soundcloud.com/users/12345",
"username": "user name"
},
"user_id": 12345
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"body": "comment body",
"created_at": "2007/09/11 15:40:24 +0000",
"id": 1234,
"kind": "comment",
"timestamp": 4960,
"track_id": 123456,
"uri": "https://api.soundcloud.com/comments/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"followers_count": 138,
"followings_count": 172,
"id": 12345,
"kind": "user",
"last_modified": "2017/04/10 14:48:03 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"public_favorites_count": 5,
"reposts_count": 0,
"uri": "https://api.soundcloud.com/users/12345",
"username": "user name"
},
"user_id": 12345
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
Returns the newly created comment on success
{{baseUrl}}/tracks/:track_id/comments
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id/comments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tracks/:track_id/comments" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id/comments"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id/comments"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id/comments");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id/comments"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tracks/:track_id/comments HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tracks/:track_id/comments")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id/comments"))
.header("authorization", "{{apiKey}}")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/comments")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tracks/:track_id/comments")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tracks/:track_id/comments');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks/:track_id/comments',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id/comments';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id/comments',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id/comments")
.post(null)
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id/comments',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks/:track_id/comments',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tracks/:track_id/comments');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks/:track_id/comments',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id/comments';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id/comments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id/comments" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id/comments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tracks/:track_id/comments', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id/comments');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tracks/:track_id/comments');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id/comments' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id/comments' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("POST", "/baseUrl/tracks/:track_id/comments", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id/comments"
headers = {"authorization": "{{apiKey}}"}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id/comments"
response <- VERB("POST", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id/comments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tracks/:track_id/comments') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id/comments";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tracks/:track_id/comments \
--header 'authorization: {{apiKey}}'http POST {{baseUrl}}/tracks/:track_id/comments \
authorization:'{{apiKey}}'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/tracks/:track_id/commentsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id/comments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"body": "comment body",
"created_at": "2007/09/11 15:40:24 +0000",
"id": 1234,
"kind": "comment",
"timestamp": 4960,
"track_id": 123456,
"uri": "https://api.soundcloud.com/comments/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"followers_count": 138,
"followings_count": 172,
"id": 12345,
"kind": "user",
"last_modified": "2017/04/10 14:48:03 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"public_favorites_count": 5,
"reposts_count": 0,
"uri": "https://api.soundcloud.com/users/12345",
"username": "user name"
},
"user_id": 12345
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 422,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 429,
"link": "https://developers.soundcloud.com/docs/api/rate-limits#errors",
"message": "Detailed message of errors, when available",
"spam_warning_urn": "soundcloud:spam-warnings:1"
}
PUT
Updates a track's information.
{{baseUrl}}/tracks/:track_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
track_id
BODY json
{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks/:track_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/tracks/:track_id" {:headers {:authorization "{{apiKey}}"}
:content-type :json
:form-params {:track {:commentable false
:description ""
:downloadable false
:embeddable_by ""
:genre ""
:isrc ""
:label_name ""
:license ""
:permalink ""
:purchase_url ""
:release ""
:release_date ""
:sharing ""
:streamable false
:tag_list ""
:title ""}}})require "http/client"
url = "{{baseUrl}}/tracks/:track_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
"content-type" => "application/json"
}
reqBody = "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"
response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/tracks/:track_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
Content = new StringContent("{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks/:track_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks/:track_id"
payload := strings.NewReader("{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}")
req, _ := http.NewRequest("PUT", url, payload)
req.Header.Add("authorization", "{{apiKey}}")
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))
}PUT /baseUrl/tracks/:track_id HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 363
{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tracks/:track_id")
.setHeader("authorization", "{{apiKey}}")
.setHeader("content-type", "application/json")
.setBody("{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks/:track_id"))
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString("{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks/:track_id")
.put(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/tracks/:track_id")
.header("authorization", "{{apiKey}}")
.header("content-type", "application/json")
.body("{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}")
.asString(); const data = JSON.stringify({
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/tracks/:track_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks/:track_id';
const options = {
method: 'PUT',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"track":{"commentable":false,"description":"","downloadable":false,"embeddable_by":"","genre":"","isrc":"","label_name":"","license":"","permalink":"","purchase_url":"","release":"","release_date":"","sharing":"","streamable":false,"tag_list":"","title":""}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks/:track_id',
method: 'PUT',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
},
processData: false,
data: '{\n "track": {\n "commentable": false,\n "description": "",\n "downloadable": false,\n "embeddable_by": "",\n "genre": "",\n "isrc": "",\n "label_name": "",\n "license": "",\n "permalink": "",\n "purchase_url": "",\n "release": "",\n "release_date": "",\n "sharing": "",\n "streamable": false,\n "tag_list": "",\n "title": ""\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/tracks/:track_id")
.put(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks/:track_id',
headers: {
authorization: '{{apiKey}}',
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
}));
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: {
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/tracks/:track_id');
req.headers({
authorization: '{{apiKey}}',
'content-type': 'application/json'
});
req.type('json');
req.send({
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/tracks/:track_id',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
data: {
track: {
commentable: false,
description: '',
downloadable: false,
embeddable_by: '',
genre: '',
isrc: '',
label_name: '',
license: '',
permalink: '',
purchase_url: '',
release: '',
release_date: '',
sharing: '',
streamable: false,
tag_list: '',
title: ''
}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tracks/:track_id';
const options = {
method: 'PUT',
headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
body: '{"track":{"commentable":false,"description":"","downloadable":false,"embeddable_by":"","genre":"","isrc":"","label_name":"","license":"","permalink":"","purchase_url":"","release":"","release_date":"","sharing":"","streamable":false,"tag_list":"","title":""}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
@"content-type": @"application/json" };
NSDictionary *parameters = @{ @"track": @{ @"commentable": @NO, @"description": @"", @"downloadable": @NO, @"embeddable_by": @"", @"genre": @"", @"isrc": @"", @"label_name": @"", @"license": @"", @"permalink": @"", @"purchase_url": @"", @"release": @"", @"release_date": @"", @"sharing": @"", @"streamable": @NO, @"tag_list": @"", @"title": @"" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks/:track_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks/:track_id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "{{apiKey}}");
("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}" in
Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks/:track_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_POSTFIELDS => json_encode([
'track' => [
'commentable' => null,
'description' => '',
'downloadable' => null,
'embeddable_by' => '',
'genre' => '',
'isrc' => '',
'label_name' => '',
'license' => '',
'permalink' => '',
'purchase_url' => '',
'release' => '',
'release_date' => '',
'sharing' => '',
'streamable' => null,
'tag_list' => '',
'title' => ''
]
]),
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}",
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/tracks/:track_id', [
'body' => '{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}',
'headers' => [
'authorization' => '{{apiKey}}',
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tracks/:track_id');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'track' => [
'commentable' => null,
'description' => '',
'downloadable' => null,
'embeddable_by' => '',
'genre' => '',
'isrc' => '',
'label_name' => '',
'license' => '',
'permalink' => '',
'purchase_url' => '',
'release' => '',
'release_date' => '',
'sharing' => '',
'streamable' => null,
'tag_list' => '',
'title' => ''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'track' => [
'commentable' => null,
'description' => '',
'downloadable' => null,
'embeddable_by' => '',
'genre' => '',
'isrc' => '',
'label_name' => '',
'license' => '',
'permalink' => '',
'purchase_url' => '',
'release' => '',
'release_date' => '',
'sharing' => '',
'streamable' => null,
'tag_list' => '',
'title' => ''
]
]));
$request->setRequestUrl('{{baseUrl}}/tracks/:track_id');
$request->setRequestMethod('PUT');
$request->setBody($body);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks/:track_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}'$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks/:track_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"
headers = {
'authorization': "{{apiKey}}",
'content-type': "application/json"
}
conn.request("PUT", "/baseUrl/tracks/:track_id", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks/:track_id"
payload = { "track": {
"commentable": False,
"description": "",
"downloadable": False,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": False,
"tag_list": "",
"title": ""
} }
headers = {
"authorization": "{{apiKey}}",
"content-type": "application/json"
}
response = requests.put(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks/:track_id"
payload <- "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"
encode <- "json"
response <- VERB("PUT", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks/:track_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.put('/baseUrl/tracks/:track_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.body = "{\n \"track\": {\n \"commentable\": false,\n \"description\": \"\",\n \"downloadable\": false,\n \"embeddable_by\": \"\",\n \"genre\": \"\",\n \"isrc\": \"\",\n \"label_name\": \"\",\n \"license\": \"\",\n \"permalink\": \"\",\n \"purchase_url\": \"\",\n \"release\": \"\",\n \"release_date\": \"\",\n \"sharing\": \"\",\n \"streamable\": false,\n \"tag_list\": \"\",\n \"title\": \"\"\n }\n}"
end
puts response.status
puts response.bodyuse std::str::FromStr;
use serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks/:track_id";
let payload = json!({"track": json!({
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
})});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/tracks/:track_id \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--data '{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}'echo '{
"track": {
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
}
}' | \
http PUT {{baseUrl}}/tracks/:track_id \
authorization:'{{apiKey}}' \
content-type:application/jsonwget --quiet \
--method PUT \
--header 'authorization: {{apiKey}}' \
--header 'content-type: application/json' \
--body-data '{\n "track": {\n "commentable": false,\n "description": "",\n "downloadable": false,\n "embeddable_by": "",\n "genre": "",\n "isrc": "",\n "label_name": "",\n "license": "",\n "permalink": "",\n "purchase_url": "",\n "release": "",\n "release_date": "",\n "sharing": "",\n "streamable": false,\n "tag_list": "",\n "title": ""\n }\n}' \
--output-document \
- {{baseUrl}}/tracks/:track_idimport Foundation
let headers = [
"authorization": "{{apiKey}}",
"content-type": "application/json"
]
let parameters = ["track": [
"commentable": false,
"description": "",
"downloadable": false,
"embeddable_by": "",
"genre": "",
"isrc": "",
"label_name": "",
"license": "",
"permalink": "",
"purchase_url": "",
"release": "",
"release_date": "",
"sharing": "",
"streamable": false,
"tag_list": "",
"title": ""
]] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks/:track_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
POST
Uploads a new track.
{{baseUrl}}/tracks
HEADERS
Authorization
{{apiKey}}
BODY multipartForm
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tracks" {:headers {:authorization "{{apiKey}}"}
:multipart [{:name "track[artwork_data]"
:content ""} {:name "track[asset_data]"
:content ""} {:name "track[commentable]"
:content ""} {:name "track[description]"
:content ""} {:name "track[downloadable]"
:content ""} {:name "track[embeddable_by]"
:content ""} {:name "track[genre]"
:content ""} {:name "track[isrc]"
:content ""} {:name "track[label_name]"
:content ""} {:name "track[license]"
:content ""} {:name "track[permalink]"
:content ""} {:name "track[purchase_url]"
:content ""} {:name "track[release]"
:content ""} {:name "track[release_date]"
:content ""} {:name "track[sharing]"
:content ""} {:name "track[streamable]"
:content ""} {:name "track[tag_list]"
:content ""} {:name "track[title]"
:content ""}]})require "http/client"
url = "{{baseUrl}}/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
"content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
Content = new MultipartFormDataContent
{
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[artwork_data]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[asset_data]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[commentable]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[description]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[downloadable]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[embeddable_by]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[genre]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[isrc]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[label_name]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[license]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[permalink]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[purchase_url]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[release]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[release_date]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[sharing]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[streamable]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[tag_list]",
}
}
},
new StringContent("")
{
Headers =
{
ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "track[title]",
}
}
},
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tracks");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tracks"
payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("authorization", "{{apiKey}}")
req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tracks HTTP/1.1
Authorization: {{apiKey}}
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 1692
-----011000010111000001101001
Content-Disposition: form-data; name="track[artwork_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[asset_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[commentable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[description]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[downloadable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[embeddable_by]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[genre]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[isrc]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[label_name]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[license]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[permalink]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[purchase_url]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release_date]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[sharing]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[streamable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[tag_list]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[title]"
-----011000010111000001101001--
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tracks")
.setHeader("authorization", "{{apiKey}}")
.setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tracks"))
.header("authorization", "{{apiKey}}")
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
.url("{{baseUrl}}/tracks")
.post(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tracks")
.header("authorization", "{{apiKey}}")
.header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
.asString(); const data = new FormData();
data.append('track[artwork_data]', '');
data.append('track[asset_data]', '');
data.append('track[commentable]', '');
data.append('track[description]', '');
data.append('track[downloadable]', '');
data.append('track[embeddable_by]', '');
data.append('track[genre]', '');
data.append('track[isrc]', '');
data.append('track[label_name]', '');
data.append('track[license]', '');
data.append('track[permalink]', '');
data.append('track[purchase_url]', '');
data.append('track[release]', '');
data.append('track[release_date]', '');
data.append('track[sharing]', '');
data.append('track[streamable]', '');
data.append('track[tag_list]', '');
data.append('track[title]', '');
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const form = new FormData();
form.append('track[artwork_data]', '');
form.append('track[asset_data]', '');
form.append('track[commentable]', '');
form.append('track[description]', '');
form.append('track[downloadable]', '');
form.append('track[embeddable_by]', '');
form.append('track[genre]', '');
form.append('track[isrc]', '');
form.append('track[label_name]', '');
form.append('track[license]', '');
form.append('track[permalink]', '');
form.append('track[purchase_url]', '');
form.append('track[release]', '');
form.append('track[release_date]', '');
form.append('track[sharing]', '');
form.append('track[streamable]', '');
form.append('track[tag_list]', '');
form.append('track[title]', '');
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks',
headers: {
authorization: '{{apiKey}}',
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
},
data: '[form]'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tracks';
const form = new FormData();
form.append('track[artwork_data]', '');
form.append('track[asset_data]', '');
form.append('track[commentable]', '');
form.append('track[description]', '');
form.append('track[downloadable]', '');
form.append('track[embeddable_by]', '');
form.append('track[genre]', '');
form.append('track[isrc]', '');
form.append('track[label_name]', '');
form.append('track[license]', '');
form.append('track[permalink]', '');
form.append('track[purchase_url]', '');
form.append('track[release]', '');
form.append('track[release_date]', '');
form.append('track[sharing]', '');
form.append('track[streamable]', '');
form.append('track[tag_list]', '');
form.append('track[title]', '');
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
options.body = form;
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const form = new FormData();
form.append('track[artwork_data]', '');
form.append('track[asset_data]', '');
form.append('track[commentable]', '');
form.append('track[description]', '');
form.append('track[downloadable]', '');
form.append('track[embeddable_by]', '');
form.append('track[genre]', '');
form.append('track[isrc]', '');
form.append('track[label_name]', '');
form.append('track[license]', '');
form.append('track[permalink]', '');
form.append('track[purchase_url]', '');
form.append('track[release]', '');
form.append('track[release_date]', '');
form.append('track[sharing]', '');
form.append('track[streamable]', '');
form.append('track[tag_list]', '');
form.append('track[title]', '');
const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tracks',
method: 'POST',
headers: {
authorization: '{{apiKey}}'
},
processData: false,
contentType: false,
mimeType: 'multipart/form-data',
data: form
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
.url("{{baseUrl}}/tracks")
.post(body)
.addHeader("authorization", "{{apiKey}}")
.addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tracks',
headers: {
authorization: '{{apiKey}}',
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write('-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[artwork_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[asset_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[commentable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[description]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[downloadable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[embeddable_by]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[genre]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[isrc]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[label_name]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[license]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[permalink]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[purchase_url]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release_date]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[sharing]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[streamable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[tag_list]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[title]"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks',
headers: {
authorization: '{{apiKey}}',
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
},
formData: {
'track[artwork_data]': '',
'track[asset_data]': '',
'track[commentable]': '',
'track[description]': '',
'track[downloadable]': '',
'track[embeddable_by]': '',
'track[genre]': '',
'track[isrc]': '',
'track[label_name]': '',
'track[license]': '',
'track[permalink]': '',
'track[purchase_url]': '',
'track[release]': '',
'track[release_date]': '',
'track[sharing]': '',
'track[streamable]': '',
'track[tag_list]': '',
'track[title]': ''
}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tracks');
req.headers({
authorization: '{{apiKey}}',
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});
req.multipart([]);
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tracks',
headers: {
authorization: '{{apiKey}}',
'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
},
data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[artwork_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[asset_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[commentable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[description]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[downloadable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[embeddable_by]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[genre]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[isrc]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[label_name]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[license]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[permalink]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[purchase_url]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release_date]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[sharing]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[streamable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[tag_list]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[title]"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const FormData = require('form-data');
const fetch = require('node-fetch');
const formData = new FormData();
formData.append('track[artwork_data]', '');
formData.append('track[asset_data]', '');
formData.append('track[commentable]', '');
formData.append('track[description]', '');
formData.append('track[downloadable]', '');
formData.append('track[embeddable_by]', '');
formData.append('track[genre]', '');
formData.append('track[isrc]', '');
formData.append('track[label_name]', '');
formData.append('track[license]', '');
formData.append('track[permalink]', '');
formData.append('track[purchase_url]', '');
formData.append('track[release]', '');
formData.append('track[release_date]', '');
formData.append('track[sharing]', '');
formData.append('track[streamable]', '');
formData.append('track[tag_list]', '');
formData.append('track[title]', '');
const url = '{{baseUrl}}/tracks';
const options = {method: 'POST', headers: {authorization: '{{apiKey}}'}};
options.body = formData;
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
@"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"track[artwork_data]", @"value": @"" },
@{ @"name": @"track[asset_data]", @"value": @"" },
@{ @"name": @"track[commentable]", @"value": @"" },
@{ @"name": @"track[description]", @"value": @"" },
@{ @"name": @"track[downloadable]", @"value": @"" },
@{ @"name": @"track[embeddable_by]", @"value": @"" },
@{ @"name": @"track[genre]", @"value": @"" },
@{ @"name": @"track[isrc]", @"value": @"" },
@{ @"name": @"track[label_name]", @"value": @"" },
@{ @"name": @"track[license]", @"value": @"" },
@{ @"name": @"track[permalink]", @"value": @"" },
@{ @"name": @"track[purchase_url]", @"value": @"" },
@{ @"name": @"track[release]", @"value": @"" },
@{ @"name": @"track[release_date]", @"value": @"" },
@{ @"name": @"track[sharing]", @"value": @"" },
@{ @"name": @"track[streamable]", @"value": @"" },
@{ @"name": @"track[tag_list]", @"value": @"" },
@{ @"name": @"track[title]", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";
NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
[body appendFormat:@"--%@\r\n", boundary];
if (param[@"fileName"]) {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
[body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
[body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
if (error) {
NSLog(@"%@", error);
}
} else {
[body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
[body appendFormat:@"%@", param[@"value"]];
}
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tracks" in
let headers = Header.add_list (Header.init ()) [
("authorization", "{{apiKey}}");
("content-type", "multipart/form-data; boundary=---011000010111000001101001");
] in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}",
"content-type: multipart/form-data; boundary=---011000010111000001101001"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tracks');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '{{apiKey}}',
'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);
$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="track[artwork_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[asset_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[commentable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[description]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[downloadable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[embeddable_by]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[genre]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[isrc]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[label_name]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[license]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[permalink]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[purchase_url]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release_date]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[sharing]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[streamable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[tag_list]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[title]"
-----011000010111000001101001--
');
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}addForm(null, null);
$request->setRequestUrl('{{baseUrl}}/tracks');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tracks' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="track[artwork_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[asset_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[commentable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[description]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[downloadable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[embeddable_by]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[genre]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[isrc]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[label_name]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[license]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[permalink]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[purchase_url]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release_date]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[sharing]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[streamable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[tag_list]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[title]"
-----011000010111000001101001--
'$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tracks' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="track[artwork_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[asset_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[commentable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[description]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[downloadable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[embeddable_by]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[genre]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[isrc]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[label_name]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[license]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[permalink]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[purchase_url]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release_date]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[sharing]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[streamable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[tag_list]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[title]"
-----011000010111000001101001--
'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
'authorization': "{{apiKey}}",
'content-type': "multipart/form-data; boundary=---011000010111000001101001"
}
conn.request("POST", "/baseUrl/tracks", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tracks"
payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
"authorization": "{{apiKey}}",
"content-type": "multipart/form-data; boundary=---011000010111000001101001"
}
response = requests.post(url, data=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tracks"
payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
encode <- "multipart"
response <- VERB("POST", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("multipart/form-data"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)
response = conn.post('/baseUrl/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[artwork_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[asset_data]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[commentable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[description]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[downloadable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[embeddable_by]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[genre]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[isrc]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[label_name]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[license]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[permalink]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[purchase_url]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[release_date]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[sharing]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[streamable]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[tag_list]\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"track[title]\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tracks";
let form = reqwest::multipart::Form::new()
.text("track[artwork_data]", "")
.text("track[asset_data]", "")
.text("track[commentable]", "")
.text("track[description]", "")
.text("track[downloadable]", "")
.text("track[embeddable_by]", "")
.text("track[genre]", "")
.text("track[isrc]", "")
.text("track[label_name]", "")
.text("track[license]", "")
.text("track[permalink]", "")
.text("track[purchase_url]", "")
.text("track[release]", "")
.text("track[release_date]", "")
.text("track[sharing]", "")
.text("track[streamable]", "")
.text("track[tag_list]", "")
.text("track[title]", "");
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.multipart(form)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tracks \
--header 'authorization: {{apiKey}}' \
--header 'content-type: multipart/form-data' \
--form 'track[artwork_data]=' \
--form 'track[asset_data]=' \
--form 'track[commentable]=' \
--form 'track[description]=' \
--form 'track[downloadable]=' \
--form 'track[embeddable_by]=' \
--form 'track[genre]=' \
--form 'track[isrc]=' \
--form 'track[label_name]=' \
--form 'track[license]=' \
--form 'track[permalink]=' \
--form 'track[purchase_url]=' \
--form 'track[release]=' \
--form 'track[release_date]=' \
--form 'track[sharing]=' \
--form 'track[streamable]=' \
--form 'track[tag_list]=' \
--form 'track[title]='echo '-----011000010111000001101001
Content-Disposition: form-data; name="track[artwork_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[asset_data]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[commentable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[description]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[downloadable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[embeddable_by]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[genre]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[isrc]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[label_name]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[license]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[permalink]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[purchase_url]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[release_date]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[sharing]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[streamable]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[tag_list]"
-----011000010111000001101001
Content-Disposition: form-data; name="track[title]"
-----011000010111000001101001--
' | \
http POST {{baseUrl}}/tracks \
authorization:'{{apiKey}}' \
content-type:'multipart/form-data; boundary=---011000010111000001101001'wget --quiet \
--method POST \
--header 'authorization: {{apiKey}}' \
--header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
--body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[artwork_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[asset_data]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[commentable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[description]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[downloadable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[embeddable_by]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[genre]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[isrc]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[label_name]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[license]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[permalink]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[purchase_url]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[release_date]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[sharing]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[streamable]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[tag_list]"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="track[title]"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
--output-document \
- {{baseUrl}}/tracksimport Foundation
let headers = [
"authorization": "{{apiKey}}",
"content-type": "multipart/form-data; boundary=---011000010111000001101001"
]
let parameters = [
[
"name": "track[artwork_data]",
"value": ""
],
[
"name": "track[asset_data]",
"value": ""
],
[
"name": "track[commentable]",
"value": ""
],
[
"name": "track[description]",
"value": ""
],
[
"name": "track[downloadable]",
"value": ""
],
[
"name": "track[embeddable_by]",
"value": ""
],
[
"name": "track[genre]",
"value": ""
],
[
"name": "track[isrc]",
"value": ""
],
[
"name": "track[label_name]",
"value": ""
],
[
"name": "track[license]",
"value": ""
],
[
"name": "track[permalink]",
"value": ""
],
[
"name": "track[purchase_url]",
"value": ""
],
[
"name": "track[release]",
"value": ""
],
[
"name": "track[release_date]",
"value": ""
],
[
"name": "track[sharing]",
"value": ""
],
[
"name": "track[streamable]",
"value": ""
],
[
"name": "track[tag_list]",
"value": ""
],
[
"name": "track[title]",
"value": ""
]
]
let boundary = "---011000010111000001101001"
var body = ""
var error: NSError? = nil
for param in parameters {
let paramName = param["name"]!
body += "--\(boundary)\r\n"
body += "Content-Disposition:form-data; name=\"\(paramName)\""
if let filename = param["fileName"] {
let contentType = param["content-type"]!
let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
if (error != nil) {
print(error as Any)
}
body += "; filename=\"\(filename)\"\r\n"
body += "Content-Type: \(contentType)\r\n\r\n"
body += fileContent
} else if let paramValue = param["value"] {
body += "\r\n\r\n\(paramValue)"
}
}
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's comments.
{{baseUrl}}/users/:user_id/comments
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/comments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/comments" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/comments"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/comments"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/comments");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/comments"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/comments HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/comments")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/comments"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/comments")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/comments")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/comments');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/comments',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/comments';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/comments',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/comments")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/comments',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/comments',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/comments');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/comments',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/comments';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/comments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/comments" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/comments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/comments', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/comments');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/comments');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/comments' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/comments' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/comments", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/comments"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/comments"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/comments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/comments') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/comments";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/comments \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/comments \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/commentsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/comments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"body": "comment body",
"created_at": "2007/09/11 15:40:24 +0000",
"id": 1234,
"kind": "comment",
"timestamp": 4960,
"track_id": 123456,
"uri": "https://api.soundcloud.com/comments/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"followers_count": 138,
"followings_count": 172,
"id": 12345,
"kind": "user",
"last_modified": "2017/04/10 14:48:03 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"public_favorites_count": 5,
"reposts_count": 0,
"uri": "https://api.soundcloud.com/users/12345",
"username": "user name"
},
"user_id": 12345
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's favorited or liked tracks. (use -users--userId-likes-tracks instead, to fetch a user's likes)
{{baseUrl}}/users/:user_id/favorites
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/favorites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/favorites" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/favorites"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/favorites"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/favorites");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/favorites"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/favorites HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/favorites")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/favorites"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/favorites")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/favorites")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/favorites');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/favorites',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/favorites';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/favorites',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/favorites")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/favorites',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/favorites',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/favorites');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/favorites',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/favorites';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/favorites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/favorites" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/favorites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/favorites', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/favorites');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/favorites');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/favorites' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/favorites' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/favorites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/favorites"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/favorites"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/favorites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/favorites') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/favorites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/favorites \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/favorites \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/favoritesimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/favorites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's liked tracks.
{{baseUrl}}/users/:user_id/likes/tracks
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/likes/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/likes/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/likes/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/likes/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/likes/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/likes/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/likes/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/likes/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/likes/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/likes/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/likes/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/likes/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/likes/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/likes/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/likes/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/likes/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/likes/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/likes/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/likes/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/likes/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/likes/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/likes/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/likes/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/likes/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/likes/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/likes/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/likes/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/likes/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/likes/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/likes/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/likes/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/likes/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/likes/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/likes/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/likes/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/likes/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/likes/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 400,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's playlists.
{{baseUrl}}/users/:user_id/playlists
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/playlists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/playlists" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/playlists"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/playlists"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/playlists");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/playlists"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/playlists HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/playlists")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/playlists"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/playlists")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/playlists")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/playlists');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/playlists',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/playlists';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/playlists',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/playlists")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/playlists',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/playlists',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/playlists');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/playlists',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/playlists';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/playlists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/playlists" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/playlists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/playlists', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/playlists');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/playlists');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/playlists' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/playlists' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/playlists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/playlists"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/playlists"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/playlists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/playlists') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/playlists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/playlists \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/playlists \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/playlistsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/playlists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"artwork_url": "",
"created_at": "2020/07/16 16:09:54 +0000",
"description": null,
"downloadable": true,
"duration": 11000,
"ean": null,
"embeddable_by": "all",
"genre": "",
"id": 12345,
"kind": "playlist",
"label": null,
"label_id": null,
"label_name": null,
"last_modified": "2020/09/08 09:13:00 +0000",
"license": "all-rights-reserved",
"likes_count": 0,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/userPermalink/sets/permalink",
"playlist_type": "",
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": null,
"release_month": null,
"release_year": null,
"sharing": "public",
"streamable": true,
"tag_list": "",
"tags": "",
"title": "permalink",
"track_count": 2,
"tracks": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"tracks_uri": "https://api.soundcloud.com/playlists/12345/tracks",
"type": "",
"uri": "https://api.soundcloud.com/playlists/12345",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_id": 1234
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user's tracks. (GET)
{{baseUrl}}/users/:user_id/tracks
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/tracks" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/tracks"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/tracks"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/tracks HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/tracks")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/tracks"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/tracks")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/tracks');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/tracks',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/tracks")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/tracks',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/tracks');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/tracks',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/tracks';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/tracks" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/tracks', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/tracks"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/tracks"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/tracks') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/tracks \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/tracks \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/tracksimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"access": "playable",
"artwork_url": "https://i1.sndcdn.com/artworks-large.jpg",
"available_country_codes": null,
"bpm": null,
"comment_count": 4,
"commentable": true,
"created_at": "2019/01/15 15:40:49 +0000",
"description": null,
"download_count": 0,
"download_url": "https://api.soundcloud.com/tracks/1234/download",
"downloadable": false,
"duration": 40000,
"embeddable_by": "all",
"favoritings_count": 271,
"genre": "Rock",
"id": 1234,
"isrc": null,
"key_signature": null,
"kind": "track",
"label_name": "some label",
"license": "all-rights-reserved",
"permalink_url": "https://soundcloud.com/userPermalink/trackPermalink",
"playback_count": 8027,
"purchase_title": null,
"purchase_url": null,
"release": null,
"release_day": 22,
"release_month": 8,
"release_year": 2019,
"reposts_count": 18,
"secret_uri": null,
"sharing": "public",
"stream_url": "https://api.soundcloud.com/tracks/1234/stream",
"streamable": true,
"tag_list": "",
"title": "Some title",
"uri": "https://api.soundcloud.com/tracks/1234",
"user": {
"avatar_url": "https://i1.sndcdn.com/avatars-large.jpg",
"id": 12345,
"kind": "user",
"last_modified": "2020/09/03 14:08:25 +0000",
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"uri": "https://api.soundcloud.com/users/12345",
"username": "user.name"
},
"user_favorite": true,
"user_playback_count": 1,
"waveform_url": "https://wave.sndcdn.com/someString.png"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user’s followers.
{{baseUrl}}/users/:user_id/followers
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/followers");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/followers" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/followers"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/followers"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/followers");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/followers"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/followers HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/followers")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/followers"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/followers")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/followers")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/followers');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followers',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/followers';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/followers',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/followers")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/followers',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followers',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/followers');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followers',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/followers';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/followers"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/followers" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/followers",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/followers', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/followers');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/followers');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/followers' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/followers' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/followers", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/followers"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/followers"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/followers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/followers') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/followers";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/followers \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/followers \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/followersimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/followers")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a list of user’s followings.
{{baseUrl}}/users/:user_id/followings
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/followings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/followings" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/followings"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/followings"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/followings");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/followings"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/followings HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/followings")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/followings"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/followings")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/followings")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/followings');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/followings';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/followings',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/followings")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/followings',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/followings');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/followings';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/followings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/followings" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/followings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/followings', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/followings');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/followings');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/followings' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/followings' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/followings", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/followings"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/followings"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/followings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/followings') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/followings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/followings \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/followings \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/followingsimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/followings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"collection": {
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
},
"next_href": "https://api.soundcloud.com/collection?client_id=client_id&page_size=10&cursor=1234567"
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"created_at": "2018/01/01 12:08:25 +0000",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"public_favorites_count": 20,
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a user's following. (use -users-{user_id} instead, to fetch the user details)
{{baseUrl}}/users/:user_id/followings/:following_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
following_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/followings/:following_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/followings/:following_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/followings/:following_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/followings/:following_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/followings/:following_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/followings/:following_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/followings/:following_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/followings/:following_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/followings/:following_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/followings/:following_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/followings/:following_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/followings/:following_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings/:following_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/followings/:following_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/followings/:following_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/followings/:following_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/followings/:following_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings/:following_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/followings/:following_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/followings/:following_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/followings/:following_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/followings/:following_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/followings/:following_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/followings/:following_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/followings/:following_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/followings/:following_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/followings/:following_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/followings/:following_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/followings/:following_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/followings/:following_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/followings/:following_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/followings/:following_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/followings/:following_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/followings/:following_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/followings/:following_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/followings/:following_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/followings/:following_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/followings/:following_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/followings/:following_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"locale": "en",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"primary_email_confirmed": true,
"private_playlists_count": 0,
"private_tracks_count": 0,
"public_favorites_count": 20,
"quota": {
"unlimited_upload_quota": false,
"upload_seconds_left": 10800,
"upload_seconds_used": 0
},
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns a user.
{{baseUrl}}/users/:user_id
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_idimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"avatar_url": "https://i1.sndcdn.com/avatars.jpg",
"city": "City",
"country": "Country",
"description": null,
"discogs_name": null,
"first_name": "First_name",
"followers_count": 0,
"followings_count": 0,
"full_name": "Full Name",
"id": 12345,
"kind": "user",
"last_modified": "2020/01/03 12:08:25 +0000",
"last_name": "Last_name",
"locale": "en",
"myspace_name": null,
"permalink": "permalink",
"permalink_url": "https://soundcloud.com/permalink",
"plan": "Free",
"playlist_count": 3,
"primary_email_confirmed": true,
"private_playlists_count": 0,
"private_tracks_count": 0,
"public_favorites_count": 20,
"quota": {
"unlimited_upload_quota": false,
"upload_seconds_left": 10800,
"upload_seconds_used": 0
},
"reposts_count": 0,
"subscriptions": [
{
"product": {
"id": "some-id",
"name": "some.name"
}
}
],
"track_count": 0,
"upload_seconds_left": 10800,
"uri": "https://api.soundcloud.com/users/1234",
"username": "some.user",
"website": null,
"website_title": null
}RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}
GET
Returns list of user's links added to their profile (website, facebook, instagram).
{{baseUrl}}/users/:user_id/web-profiles
HEADERS
Authorization
{{apiKey}}
QUERY PARAMS
user_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/web-profiles");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/users/:user_id/web-profiles" {:headers {:authorization "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/users/:user_id/web-profiles"
headers = HTTP::Headers{
"authorization" => "{{apiKey}}"
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/users/:user_id/web-profiles"),
Headers =
{
{ "authorization", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/users/:user_id/web-profiles");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/users/:user_id/web-profiles"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/users/:user_id/web-profiles HTTP/1.1
Authorization: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/web-profiles")
.setHeader("authorization", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/users/:user_id/web-profiles"))
.header("authorization", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/users/:user_id/web-profiles")
.get()
.addHeader("authorization", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/web-profiles")
.header("authorization", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/users/:user_id/web-profiles');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/web-profiles',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/users/:user_id/web-profiles';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/users/:user_id/web-profiles',
method: 'GET',
headers: {
authorization: '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/users/:user_id/web-profiles")
.get()
.addHeader("authorization", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/users/:user_id/web-profiles',
headers: {
authorization: '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/web-profiles',
headers: {authorization: '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/users/:user_id/web-profiles');
req.headers({
authorization: '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/users/:user_id/web-profiles',
headers: {authorization: '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/users/:user_id/web-profiles';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/web-profiles"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/users/:user_id/web-profiles" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/users/:user_id/web-profiles",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/users/:user_id/web-profiles', [
'headers' => [
'authorization' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/users/:user_id/web-profiles');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/users/:user_id/web-profiles');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/web-profiles' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/web-profiles' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'authorization': "{{apiKey}}" }
conn.request("GET", "/baseUrl/users/:user_id/web-profiles", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/users/:user_id/web-profiles"
headers = {"authorization": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/users/:user_id/web-profiles"
response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/users/:user_id/web-profiles")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/users/:user_id/web-profiles') do |req|
req.headers['authorization'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/users/:user_id/web-profiles";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/users/:user_id/web-profiles \
--header 'authorization: {{apiKey}}'http GET {{baseUrl}}/users/:user_id/web-profiles \
authorization:'{{apiKey}}'wget --quiet \
--method GET \
--header 'authorization: {{apiKey}}' \
--output-document \
- {{baseUrl}}/users/:user_id/web-profilesimport Foundation
let headers = ["authorization": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/web-profiles")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
[
{
"created_at": "1995/10/20 12:10:39 +0000",
"id": 1234,
"kind": "web-profile",
"service": "facebook",
"title": "my facebook",
"url": "http://facebook.com",
"username": "username"
}
]RESPONSE HEADERS
Content-Type
application/json; charset=utf-8
RESPONSE BODY json
{
"code": 401,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"code": 404,
"link": "https://developers.soundcloud.com/docs/api/explorer/open-api",
"message": "Detailed message of errors, when available"
}